# On Properties and State Complexity of Deterministic State-Partition Automata

Galina Jirásková, Tomáš Masopust

<figure><img src="image_1.png" /></figure>

## To cite this version:

Galina Jirásková, Tomáš Masopust. On Properties and State Complexity of Deterministic State-Partition Automata. 7th International Conference on Theoretical Computer Science (TCS), Sep 2012, Amsterdam, Netherlands. pp.164-178, 10.1007/978-3-642-33475-7_12. hal-01556220

HAL Id: hal-01556220

https://inria.hal.science/hal-01556220

Submitted on 4 Jul 2017

HAL is a multi-disciplinary open access archive for the deposit and dissemination of scientific research documents, whether they are published or not. The documents may come from teaching and research institutions in France or abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est destinée au dépôt et à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

<figure><img src="image_2.png" /></figure>

Distributed under a Creative Commons Attribution 4.0 International License
# On Properties and State Complexity of Deterministic State-Partition Automata

Galina Jirásková¹,\* and Tomáš Masopust²,\*\*

¹ Mathematical Institute, Slovak Academy of Sciences
Grešákova 6, 040 01 Košice, Slovak Republic
jiraskov@saske.sk

² Institute of Mathematics, Academy of Sciences of the Czech Republic
Žižkova 22, 616 62 Brno, Czech Republic
masopust@math.cas.cz

**Abstract.** A deterministic automaton accepting a regular language $L$ is a state-partition automaton with respect to a projection $P$ if the state set of the deterministic automaton accepting the projected language $P(L)$, obtained by the standard subset construction, forms a partition of the state set of the automaton. In this paper, we study fundamental properties of state-partition automata. We provide a construction of the minimal state-partition automaton for a regular language and a projection, discuss closure properties of state-partition automata under the standard constructions of deterministic automata for regular operations, and show that almost all of them fail to preserve the property of being a state-partition automaton. Finally, we define the notion of a state-partition complexity, and prove the tight bound on the state-partition complexity of regular languages represented by incomplete deterministic automata.

**Key words:** Regular languages, finite automata, descriptional complexity, projections, state-partition automata.

## 1 Introduction

A deterministic finite automaton $G$ accepting a regular language $L$ is a state-partition automaton with respect to a projection $P$ if the state set of the deterministic automaton accepting the projected language $P(L)$, obtained by the standard subset construction [5, 23], forms a partition of the state set of the automaton $G$. This means that the projection of a string uniquely specifies the state of the projected automaton. Therefore, all projected strings of a language with the same observation, that is, with the same projections, lead to the same state of the projected automaton. This property immediately implies that the size of the minimal state-partition automaton is not smaller than the size of the minimal deterministic automaton accepting the projected language.

<footnote>\* Research supported by the Slovak Research and Development Agency under contract APVV-0035-10 "Algorithms, Automata, and Discrete Data Structures".</footnote>

<footnote>\*\* Research supported by the GAČR grant no. P202/11/P028 and by RVO: 67985840.</footnote>
From the practical point of view, state-partition automata are of interest
in engineering and computer science, especially in applications where the user,
supervisor, or controller has only a partial observation of the whole behavior
of a system, which is modeled by a projection. From the theoretical point of
view, state-partition automata have found applications as a proof formalism for
systems with partial observations. Namely, they have been successfully used to
simplify constructions and proofs, and are useful in applications of natural pro-
jections to obtain or describe an abstraction of a system. Note that projections
are sometimes generalized to so-called *causal reporter maps*, see [21, 24]. We refer
the reader to [3, 4, 11, 12] for applications of state-partition automata in super-
visory control of discrete-event systems. Note that state-partition automata are
related to the Schützenberger covering. More specifically, the construction of a
state-partition automaton is close to the Schützenberger construct [15].

A system represented by a state-partition automaton with respect to a pro-
jection that describes an abstraction or a partial observation has a projected
automaton that is not larger than the original automaton. This is the most im-
portant property from the application point of view. Notice that, up to now,
there is only one well-known condition ensuring that a projected automaton is
smaller than the original automaton, an *observer property*, cf. [20]. The study of
state-partition automata is thus a further step to the understanding and char-
acterization of the class of automata useful for practical applications in, e.g.,
coordination or hierarchical supervisory control of discrete-event systems [1, 9,
10, 17, 18].

In this paper, we discuss fundamental properties of state-partition automata.
In Section 3, we recall the known result proving that every regular language has
a state-partition automaton with respect to a given projection. A procedure to
construct this automaton is also known, see [3]. We repeat the construction here
and use it to obtain the minimal state-partition automaton for a given language
and a projection. The last result of this section describes a regular language and
two projections with respect to which the language has no state-partition au-
tomaton. This negative result indicates that state-partition automata are useful
for systems with either a partial observation or abstraction, but not with the
combination of both.

Then, in Section 4, we study the closure properties of state-partition au-
tomata under the standard constructions of deterministic automata for the op-
erations of complement, union, intersection, concatenation, Kleene star, reversal,
cyclic shift, and left and right quotients. We show that almost all of them fail
to preserve the property of being a state-partition automaton. Only two of the
considered operations preserve this property, namely, the construction of a de-
terministic automaton for the right quotient of two regular languages, and the
construction of a deterministic automaton for the complement of regular lan-
guages represented by complete deterministic automata.

Finally, in the last section of this paper, we introduce and study the *state-partition complexity* of regular languages with respect to a projection, defined as the smallest number of states in any state-partition automaton (with respect
to the projection) accepting the language. The first result of this section shows that a language represented by a minimal incomplete deterministic automaton with $n$ states has state-partition complexity at most $3n \cdot 2^{n-3}$. The second result then proves the tightness of this upper bound using a language defined over a three-letter alphabet and a projection on binary strings.

## 2 Preliminaries and Definitions

In this paper, we assume that the reader is familiar with the basic notions and concepts of formal languages and automata theory, and we refer the reader to [5, 14, 16] for all details and unexplained notions.

For a finite non-empty set $\Sigma$, called an alphabet, the set $\Sigma^*$ represents the free monoid generated by $\Sigma$. A string over $\Sigma$ is any element of $\Sigma^*$, and the unit of $\Sigma^*$ is the empty string denoted by $\varepsilon$. A language over $\Sigma$ is any subset of $\Sigma^*$. For a string $w$ in $\Sigma^*$, let $|w|$ denote the length of $w$, and for a symbol $a$ in $\Sigma$, let $|w|_a$ denote the number of occurrences of the symbol $a$ in $w$. If $w = xyz$, for strings $x, y, z, w$ in $\Sigma^*$, then $x$ is a prefix of $w$, and $y$ is a factor of $w$.

A deterministic finite automaton (a DFA, for short) is a quintuple $G = (Q, \Sigma, \delta, s, F)$, where $Q$ is a finite non-empty set of states, $\Sigma$ is an input alphabet, $\delta: Q \times \Sigma \to Q$ is a partial transition function, $s \in Q$ is the initial (or start) state, and $F \subseteq Q$ is the set of final states. Note that we consider incomplete deterministic finite automata that are also called *generators* in the literature, cf. [2, 22]. That is why we prefer to use $G$ to denote an incomplete deterministic automaton. The transition function can be naturally extended to the domain $Q \times \Sigma^*$ by induction. The language *accepted* by the automaton $G$ is the set of strings $L(G) = \{w \in \Sigma^* | \delta(s, w) \in F\}$. A state $q$ of $G$ is called *reachable* if $q = \delta(s, w)$ for a string $w$ in $\Sigma^*$, and it is called *useful*, or *co-reachable*, if $\delta(q, w) \in F$ for a string $w$.

A nondeterministic finite automaton (an NFA, for short) is a quintuple $N = (Q, \Sigma, \delta, S, F)$, where $Q, \Sigma$, and $F$ are as in a DFA, $S \subseteq Q$ is the set of initial states, and $\delta: Q \times (\Sigma \cup \{\varepsilon\}) \to 2^Q$ is the nondeterministic transition function that can be extended to the domain $2^Q \times \Sigma^*$ by induction. The language *accepted* by the NFA $N$ is defined as the set $L(N) = \{w \in \Sigma^* | \delta(S, w) \cap F \neq \emptyset\}$. Notice that our NFAs may have $\varepsilon$-transitions and multiple initial states. However, $\varepsilon$-transitions and multiple initial states can be eliminated by a standard technique [5].

Two automata are equivalent if they accept the same language. Every NFA $N = (Q, \Sigma, \delta, S, F)$ without $\varepsilon$-transitions can be converted to an equivalent DFA $\det(N) = (2^Q, \Sigma, \delta_d, s_d, F_d)$ by an algorithm known as the “subset construction” [13], where we have

$$ \begin{align*} \delta_d(R, a) &= \delta(R, a) \text{ for each } R \text{ in } 2^Q \text{ and } a \text{ in } \Sigma, \\ s_d &= S, \text{ and} \\ F_d &= \{R \in 2^Q \mid R \cap F \neq \emptyset\}. \end{align*} $$
We call the deterministic automaton $\det(N)$ the subset automaton corresponding to the automaton $N$. Notice that the state set of the subset automaton is the set of all subsets of $Q$, even though some of them may be unreachable from the initial state $s_d$.

Let $\Sigma$ be an alphabet and $\Sigma_o \subseteq \Sigma$. A homomorphism $P$ from $\Sigma^*$ to $\Sigma_o^*$ is called a (natural) projection if it is defined by $P(a) = a$ for each $a$ in $\Sigma_o$ and $P(a) = \varepsilon$ for each $a$ in $\Sigma \setminus \Sigma_o$. The inverse image of $P$ is a mapping $P^{-1}$ from $\Sigma_o^*$ to $2^{\Sigma_o^*}$ defined by $P^{-1}(w) = \{u \in \Sigma_o^* | P(u) = w\}$.

Let $G = (Q, \Sigma, \delta, s, F)$ be a DFA accepting a language $L$ and $P$ be the projection from $\Sigma^*$ to $\Sigma_o^*$ with $\Sigma_o \subseteq \Sigma$. From the DFA $G$, we construct an NFA $N_G$ accepting the language $P(L)$ by replacing all transitions labeled by symbols from $\Sigma \setminus \Sigma_o$ with $\varepsilon$-transitions, and by eliminating these $\varepsilon$-transitions. Then the projected automaton for the language $P(L)$ is the deterministic automaton

$$P(G) = (Q', \Sigma_o, \delta', s', F')$$

that forms the reachable part of the subset automaton $\det(N_G)$. Thus, $Q'$ is the set of all states of $2^Q$ reachable from the initial state $s'$. Notice that we do not eliminate states, from which no final state is reachable. This is due to applications in supervisory control, where this problem is known as the problem of nonblockingness [2].

A DFA $G = (Q, \Sigma, \delta, s, F)$ is a state-partition automaton (an SPA, for short) with respect to a projection $P$ from $\Sigma^*$ to $\Sigma_o^*$ with $\Sigma_o \subseteq \Sigma$ if the states of the projected automaton $P(G) = (Q', \Sigma_o, \delta', s', F')$ are pairwise disjoint as sets. Note that if all states of $G$ are reachable, then the state set of the projected automaton $P(G)$ defines a partition of the state set of $G$.

For an automaton $A$ (deterministic or nondeterministic), let $\mathrm{sc}(A)$ denote the number of states of the automaton $A$.

We immediately have the following result.

**Lemma 1.** Let $G$ be a DFA over an alphabet $\Sigma$ that has no unreachable states. Let $P$ be a projection from $\Sigma^*$ to $\Sigma_o^*$ with $\Sigma_o \subseteq \Sigma$. If $G$ is a state-partition automaton with respect to $P$, then $\mathrm{sc}(P(G)) \le \mathrm{sc}(G)$. $\square$

Now we define a parallel composition of two incomplete deterministic automata, which is basically the intersection of two automata defined over two different alphabets. Therefore, it is first necessary to unify their alphabets by adding the missing symbols.

For two deterministic finite automata $G_1 = (Q_1, \Sigma_1, \delta_1, s_1, F_1)$ and $G_2 = (Q_2, \Sigma_2, \delta_2, s_2, F_2)$, we define the parallel composition of $G_1$ and $G_2$, denoted by $G_1 \parallel G_2$, as the reachable part of the DFA $(Q_1 \times Q_2, \Sigma_1 \cup \Sigma_2, \delta, (s_1, s_2), F_1 \times F_2)$, where

$$\delta((p, q), a) = \begin{cases} (\delta_1(p, a), \delta_2(q, a)), & \text{if } \delta_1(p, a) \text{ is defined in } G_1 \text{ and } \delta_2(q, a) \text{ is defined in } G_2; \\ (\delta_1(p, a), q), & \text{if } \delta_1(p, a) \text{ is defined in } G_1 \text{ and } a \notin \Sigma_2; \\ (p, \delta_2(q, a)), & \text{if } a \notin \Sigma_1 \text{ and } \delta_2(q, a) \text{ is defined in } G_2; \\ \text{undefined}, & \text{otherwise.} \end{cases}$$
From the language point of view, it can be shown that

$$L(G_1 \parallel G_2) = P_1^{-1}(L(G_1)) \cap P_2^{-1}(L(G_2)),$$

where $P_i$ is the projection from $(\Sigma_1 \cup \Sigma_2)^*$ to $\Sigma_i^*$ for $i = 1, 2$.

Let us briefly recall definitions of the operations of reversal, cyclic shift, and left and right quotients for languages over an alphabet $\Sigma$. The reversal of a string $w$ over $\Sigma$ is defined by $\varepsilon^R = \varepsilon$ and $(va)^R = av^R$ for a symbol $a$ in $\Sigma$ and a string $v$ in $\Sigma^*$. The reversal of a language $L$ is the language $L^R = \{w^R \in \Sigma^* | w \in L\}$. The cyclic shift of a language $L$ is defined as the language $L^{shift} = \{uv \in \Sigma^* | vu \in L\}$. The left and right quotients of a language $L$ by a language $K$ are the languages $K \setminus L = \{x \in \Sigma^* | \text{ there exists } w \in K \text{ such that } wx \in L\}$ and $L/K = \{x \in \Sigma^* | \text{ there exists } w \in K \text{ such that } xw \in L\}$, respectively. By $L^c$ we denote the complement of a language $L$, that is, the language $\Sigma^* \setminus L$.

## 3 Minimal State-Partition Automata

The fundamental question is whether every regular language can be accepted by a state-partition automaton with respect to a given projection. If this is the case, can we construct such a state-partition automaton efficiently? The answer to this question is known, and we repeat it in the following theorem. Although a proof has been given in [3], we prefer to recall it here since some fundamental observations play a role later in the paper.

**Theorem 1 ([3, 4]).** Let $P$ be a projection from $\Sigma^*$ to $\Sigma_o^*$ with $\Sigma_o \subseteq \Sigma$. Let $L$ be a language over the alphabet $\Sigma$, and let $G$ be a DFA accepting the language $L$. Then the automaton $P(G) \parallel G$ is a state-partition automaton with respect to the projection $P$ that accepts the language $L$.

*Proof.* Let $G = (Q, \Sigma, \delta, s, F)$ be a DFA accepting the language $L$, and let $P(G) = (Q', \Sigma_o, \delta', s', F')$ be the corresponding projected automaton. By definition of the parallel composition and the comment below the definition, we have that

$$L(P(G) \parallel G) = P^{-1}(P(L(G))) \cap L(G) = L(G).$$

Hence, the automaton $P(G) \parallel G$ accepts the language $L$.

Let $w$ be a string over the alphabet $\Sigma_o$. Then the state of the projected automaton $P(P(G) \parallel G)$ reached from the initial state by the string $w$ is

$$\{(\delta'(s', w), q) | q \in \delta'(s, P^{-1}(w))\}.$$

Since $\delta(s, P^{-1}(w)) = \delta'(s', w)$, by definition of the transition function of the automaton $P(G)$, the state reachable from its initial state by the string $w$ in the DFA $P(P(G) \parallel G)$ is, in fact,

$$\{(\delta'(s', w), q) | q \in \delta'(s', w)\}.$$

It then follows that the states of the projected automaton $P(P(G) \parallel G)$ reachable by two different strings are either the same or disjoint. □
Next we prove that the state-partition automaton constructed from a minimal DFA using the construction of the previous theorem is the minimal state-partition automaton with respect to the number of states. To prove this, we need the notion of isomorphic automata, and the result proved in the following lemma.

Let $G_1 = (Q_1, \Sigma, \delta_1, s_1, F_1)$ and $G_2 = (Q_2, \Sigma, \delta_2, s_2, F_2)$ be two DFAs. Let $f$ be a mapping from $Q_1$ to $Q_2$ such that

* $f(\delta_1(q, a)) = \delta_2(f(q), a)$ for each $q$ in $Q_1$ and $a$ in $\Sigma$,

* $f(s_1) = s_2$, and

* $q \in F_1$ if and only if $f(q) \in F_2$.

The mapping $f$ is called a *homomorphism* from $G_1$ to $G_2$. If $f$ is a bijection, then it is called an *isomorphism*, and $G_1$ and $G_2$ are said to be isomorphic.

The next lemma shows that the parallel composition of automata $P(G)$ and $G$ is isomorphic to $G$ for a state-partition automaton $G$.

**Lemma 2.** Let $G$ be an SPA with respect to a projection $P$ from $\Sigma^*$ to $\Sigma_o^*$, in which all states are reachable. Then the DFA $P(G) \parallel G$ is isomorphic to $G$.

*Proof.* Let $G = (Q, \Sigma, \delta, s, F)$ be a state-partition automaton with respect to the projection $P$, and let $P(G) = (Q', \Sigma_o, \delta', s', F')$ be the corresponding projected automaton. Define a mapping $f: Q' \times Q \to Q$ by $f(X, q) = q$. Then it holds that $\delta(q, a) = \delta(f(X, q), a)$, and $f$ is an isomorphism from $P(G) \parallel G$ to $G$. $\square$

The following result constructs the minimal state-partition automaton for a given regular language and a projection.

**Theorem 2.** Let $L$ be a regular language over an alphabet $\Sigma$, and let $G$ be the minimal DFA accepting the language $L$. Let $P$ be a projection from $\Sigma^*$ to $\Sigma_o^*$. Then the DFA $P(G) \parallel G$ is the minimal state-partition automaton with respect to the projection $P$ that accepts the language $L$.

*Proof.* Let $G = (Q, \Sigma, \delta, s, F)$ be the minimal DFA accepting the language $L$, and let $G_2 = (Q_2, \Sigma, \delta_2, s_2, F_2)$ be a state-partition automaton with respect to the projection $P$ that also accepts the language $L$. We may assume that all states of the DFA $G_2$ are reachable and useful; otherwise, we can remove unreachable and useless states from $G_2$ and obtain a smaller state-partition automaton.

Define a mapping $f: Q_2 \to Q$ as follows. For a state $q$ in $Q_2$ that is reachable in the automaton $G_2$ from the initial state $s_2$ by a string $w$, set $f(q) = \delta(s, w)$, that is, $f(q)$ is a state in $Q$ that is reachable in the automaton $G$ from the initial state $s$ by the string $w$. Notice that $f$ is well-defined since if a state in $Q_2$ is reached by two different strings $u$ and $v$, then states $\delta(s, u)$ and $\delta(s, v)$ must be equivalent in the automaton $G$, and since $G$ is minimal, we must have $\delta(s, u) = \delta(s, v)$.

Next, we have $f(\delta_2(q, a)) = \delta(f(q), a)$ for each state $q$ in $Q_2$ and symbol $a$ in $\Sigma$, $f(s_2) = s$, and $q \in F_2$ if and only if $f(q) \in F$. Hence $f$ is a homomorphism from $G_2$ to $G$.
Now, extend the mapping $f$ to a mapping from the state set of the automaton $P(G_2) \parallel G_2$ to the state set of the automaton $P(G) \parallel G$ by setting

$$f(X, q) = (f(X), f(q)).$$

Then $f$ is surjective. Since the automaton $G_2$ is a state-partition automaton with respect to the projection $P$, we have, using Lemma 2, that

$$\mathrm{sc}(P(G) \parallel G) \leq \mathrm{sc}(P(G_2) \parallel G_2) = \mathrm{sc}(G_2).$$

This completes the proof. □

**Corollary 1.** Let $L$ be a regular language over an alphabet $\Sigma$, and let $P$ be a projection from $\Sigma^*$. Then the minimal state-partition automaton accepting the language $L$ is unique up to isomorphism. □

It is natural to ask whether an automaton can be a state-partition automaton with respect to more than one projection. This property would be useful in applications, where both an abstraction and a partial observation are combined, cf. [1]. Unfortunately, the following result shows that this does not hold true in general [8].

**Lemma 3.** There exist a language $L$ and projections $P$ and $\tilde{P}$ such that no DFA accepting the language $L$ is a state-partition automaton with respect to both projections $P$ and $\tilde{P}$.

*Proof.* Let $\Sigma = \{a, b\}$. Let $P$ and $\tilde{P}$ be projections from $\Sigma^*$ onto $\{a\}^*$ and $\{b\}^*$, respectively. Consider the language $L = (ab)^*$. Assume that $G = (Q, \Sigma, \delta, s, F)$ is a state-partition automaton for both projections $P$ and $\tilde{P}$ accepting the language $L$. Notice that the DFA $G$ does not have any loop, that is, no state of $G$ goes to itself on any symbol, because otherwise the automaton $G$ would accept a string that does not belong to the language $L$.

Let $w$ be a string of the language $L$ of length at least $|Q|$. Then at least one state appears twice in the computation of the automaton $G$ on the string $w$. Let $p$ be the first such state. Then $w = xyz$, where $x$ is the shortest prefix of $w$ such that the initial state $s$ goes to state $p$ by $x$, and $y$ is the shortest non-empty factor of $w$ by which $p$ goes to itself. Since the automaton $G$ has no loops, the length of $y$ is at least two. Therefore, $y = cy'd$, where $c, d \in \{a, b\}$. In addition, $c \neq d$ because $xzyz = xcy'dcy'dz$ belongs to the language $L$. Let $q$ be the state of the automaton $G$ that is reached from the state $p$ on reading the string $cy'$. Fig. 1 illustrates the computation of $G$ on the string $w$. Since $x$ is the shortest prefix of $w$ that moves $G$ to state $p$, and $y$ is the shortest non-empty factor of $w$ by which $p$ goes to itself, we have $p \neq q$.

In case $d = b$, we consider the projected automaton

$$P(G) = (Q', \{a\}, \delta', s', F').$$

Let $X = \delta'(s', P(x))$ and $Y = \delta'(X, P(ay'))$ be two states of the automaton $P(G)$. Then $p \in X$ and $p, q \in Y$. Notice that $X = \delta(s, P^{-1}(P(x)))$. Since
<figure><img src="image_3.png" /><figcaption>Fig. 1. The computation of $G$ on the string $w = xcy'dz$.</figcaption></figure>

$c = a$ and $w \in L$, we have $x = (ab)^k$ for a non-negative integer $k$. Therefore, $P^{-1}(P(x)) = P^{-1}(a^k)$.

Assume that there exists a string $u$ in $P^{-1}(a^k)$ that moves the automaton $G$ from the initial state $s$ to the state $q$. Then the string $udz$ is accepted by the automaton $G$. Since $d = b$, we must have $u = (ab)^{k-1}a$. However, then the state $q$ would be the first state in the computation on the string $w$ that appears at least twice in it, which contradicts the choice of the state $p$. It follows that $q \notin X$, and, therefore, $X \neq Y$. Hence, the automaton $G$ is not a state-partition automaton with respect to the projection $P$.

The case $d = a$ is similar. $\square$

# 4 Closure Properties

Since every regular language has a state-partition automaton with respect to a given projection, the class of languages accepted by state-partition automata is closed under all regular operations. In the following, we consider the closure properties of state-partition automata under the standard constructions of deterministic automata for regular operations as described in the literature [5, 16, 19, 23]. Hence, we investigate the following question: Given state-partition automata with respect to a projection, is the deterministic automaton resulting from the standard construction for a regular operation a state-partition automaton with respect to the same projection?

We prove that almost all standard constructions, except for the complement of complete state-partition automata and right quotient, fail to preserve the property of being a state-partition automaton.

**Theorem 3.** *State-partition automata are not closed under the operations of complement, intersection, union, concatenation, star, reversal, cyclic shift, and left quotient.*

*Proof.* We briefly recall the standard construction of a deterministic automaton for each operation under consideration. Let us emphasize that we do not minimize the resulting deterministic automata.

*Complement:* To get a deterministic automaton for complement from a possibly incomplete DFA $G$, add the dead state, if necessary, and interchange the final and non-final states. We prove that state-partition automata are not closed under this operation.

Consider the two-state DFA $G$ in Fig. 2 (left). The DFA accepts the language $ab^*$. Let $P$ be the projection from $\{a, b\}^*$ to $\{a\}^*$. Then $G$ is a state-partition
<figure><img src="image_4.png" /><figcaption>**Fig. 2.** SPA $G$ (left), and DFA $G^c$ for the complement of the language $L(G)$ (right); projection $P: \{a, b\}^* \to \{a\}^*$.</figcaption></figure>

automaton with respect to the projection $P$ since the projected automaton $P(G)$ is deterministic. However, the complement of $G$, the DFA $G^c$ shown in Fig. 2 (right), is not a state-partition automaton with respect to the projection $P$ because we have to add the dead state, 3, which then appears in two different reachable sets of the projected automaton $P(G^c)$, namely, in $\{1, 3\}$ reached by $\varepsilon$ and in $\{2, 3\}$ reached by $a$. However, as the next theorem shows, the resulting DFA is a state-partition automaton if the given DFA is complete.

*Intersection and union:* To get the deterministic automaton for intersection and union, we apply the standard cross-product construction.

Consider two automata $G_1$ and $G_2$ shown in Fig. 3, and their cross-product automaton $G_1 \times G_2$ depicted in Fig. 3. In the case of intersection, the only final state is state 3, while in the case of union, the final states are states 3 and 4. Let $P$ be the projection from $\{a, b\}^*$ to $\{a\}^*$. Both $G_1$ and $G_2$ are state-partition automata with respect to the projection $P$. However, the automaton $G_1 \times G_2$ is not since the sets $\{2, 3\}$ and $\{3, 4\}$ are reachable in the projected automaton $P(G_1 \times G_2)$ by strings $a$ and $aa$, respectively.

*Concatenation:* Recall that an NFA for concatenation of two DFAs $G_1$ and $G_2$ is obtained from $G_1$ and $G_2$ by adding $\varepsilon$-transitions from final states of $G_1$ to the initial state of $G_2$, and by setting the initial state to be the initial state of $G_1$, and final states to be final states of $G_2$. The corresponding subset automaton restricted to its reachable states provides the resulting DFA for concatenation.

Now, let $G$ be the DFA shown in Fig. 4 (left). Let $P$ be the projection from $\{a, b\}^*$ to $\{b\}^*$. The projected automaton $P(G)$ is a one-state automaton and, therefore, the DFA $G$ is a state-partition automaton with respect to the projection $P$. The DFA $G \cdot G$ for concatenation is depicted in Fig. 4 (right), and states $\{1, 2, 3\}$ and $\{1, 2, 3, 4\}$ are reachable in the projected automaton $P(G \cdot G)$ by strings $\varepsilon$ and $b$, respectively. Hence, the DFA $G \cdot G$ for concatenation is not a state-partition automaton for the projection $P$.

<figure><img src="image_5.png" /><figcaption>**Fig. 3.** SPAs $G_1$ (left) and $G_2$ (middle), and their cross-product $G_1 \times G_2$ (right); projection $P: \{a, b\}^* \to \{a\}^*$.</figcaption></figure>
<figure><img src="image_6.png" /><figcaption>**Fig. 4.** SPA $G$ (left) and DFA $G \cdot G$ for concatenation of the languages $L(G) \cdot L(G)$ (right); projection $P : \{a, b\}^* \to \{b\}^*$.</figcaption></figure>

**Star:** To construct an NFA for star of a DFA $G$, add a new initial and final state and $\varepsilon$-transitions from all final states, including the new one, to the original initial state of the automaton $G$. The subset construction results in a DFA for star.

Consider the DFA $G$ in Fig. 5 (left), and the projection $P$ from $\{a, b, c\}^*$ to $\{a, b\}^*$. The automaton $G$ is a state-partition automaton with respect to the projection $P$ since the projected automaton $P(G)$ is deterministic. However, the deterministic automaton $G^*$ for star, shown in Fig. 5 (right), is not a state-partition automaton with respect to the projection $P$ because the sets $\{3\}$ and $\{3, 4\}$ are reachable in the projected automaton $P(G^*)$ by strings $ab$ and $aba$, respectively.

<figure><img src="image_7.png" /><figcaption>**Fig. 5.** SPA $G$ (left), and DFA $G^*$ for the star of the language $L(G)$ (right); projection $P : \{a, b, c\}^* \to \{a, b\}^*$.</figcaption></figure>

**Reversal:** We can get an NFA for reversal from a DFA $G$ by swapping the roles of initial and final states, and by reversing all transitions. After the application of the subset construction, we obtain a DFA for reversal.

Consider the DFA $G$ in Fig. 6 (left), and the projection $P$ from $\{a, b, c\}^*$ to $\{a, c\}^*$. The DFA $G$ is a state-partition automaton with respect to $P$ since the states of the projected automaton $P(G)$ are $\{2, 3\}$ and $\{1\}$. On the other hand, the DFA $G^R$ in Fig. 6 (right) is not a state-partition automaton with respect to the projection $P$ because the sets $\{2\}$ and $\{2, 3\}$ are reachable in the projected automaton $P(G^R)$ by strings $a$ and $ac$, respectively.

**Cyclic shift:** For the construction of an NFA for cyclic shift, we refer to [7]. Fig. 7 (middle) shows an NFA for the cyclic shift of the language accepted by the DFA $G$ of Fig. 7 (left). Let $P$ be the projection from $\{a, b\}^*$ to $\{b\}^*$. Then $G$ is a state-partition automaton with respect to the projection $P$ since the projected automaton $P(G)$ has just one state $\{1, 2\}$. However, the automaton $G^{shift}$ in Fig. 7 (right) is not a state-partition automaton with respect to the projection
<figure><img src="image_8.png" /><figcaption>**Fig. 6.** SPA $G$ (left), and DFA $G^R$ for the reversal of the language $L(G)$ (right); projection $P: \{a, b, c\}^* \to \{a, c\}^*$.</figcaption></figure>

<figure><img src="image_9.png" /><figcaption>**Fig. 7.** SPA $G$ (left), NFA for $shift(L(G))$ (middle), and DFA $G^{shift}$ (right); projection $P: \{a, b\}^* \to \{b\}^*$.</figcaption></figure>

$P$ since states $\{1, 2, 3\}$ and $\{2, 3, 4, 5, 6, 7, 8\}$ are reachable by strings $\varepsilon$ and $b$, respectively.

*Left quotient:* Construct a DFA for left quotient by a string $w$ from a DFA $G$ by making the state reached after reading the string $w$ initial.

Consider the DFA $G$ shown in Fig. 8 (left) and the projection $P$ from $\{a, b\}^*$ to $\{b\}^*$. The automaton $G$ is a state-partition automaton with respect to the projection $P$ as in the case of cyclic shift. The automaton $a\backslash G$ for the left quotient by the string $a$ is shown in Fig. 8 (right). It is not a state-partition automaton with respect to the projection $P$ since the sets $\{2\}$ and $\{1, 2\}$ are reachable in the projected automaton by strings $\varepsilon$ and $b$, respectively. $\square$

The following theorem demonstrates that if the structure of the automaton is not changed after an operation, then the automaton remains state-partition with respect to the same projection.

**Theorem 4.** *State-partition automata are closed under the operations of right quotient and complement of complete state-partition automata.*

<figure><img src="image_10.png" /><figcaption>**Fig. 8.** SPA $G$ (left) and DFA $a\backslash G$ for the left quotient by the string $a$ (right); projection $P: \{a, b\}^* \to \{b\}^*$.</figcaption></figure>
*Proof.* Let $G$ be a complete state-partition automaton. Construct a deterministic automaton $G^c$ for the complement of $L(G)$ from the DFA $G$ by interchanging final and non-final states. The result now follows from the fact that the states of the projected automaton $P(G^c)$ are the same as the states of the projected automaton $P(G)$ since the structure of the automaton $G^c$ is the same as the structure of the automaton $G$.

Now, consider the right quotient of a language $L(G)$ by a language $K$; here, the DFA $G$ may be incomplete. Construct an automaton for the right quotient $L(G)/K$ from the automaton $G$ by replacing the set of final states with the set of states of $G$ from which a string of the language $K$ is accepted. Again, the structure of the automaton remains the same; we only change the set of final states. $\square$

# 5 State-Partition Complexity

Let $L$ be a regular language over an alphabet $\Sigma$, and let $P$ be a projection from $\Sigma^*$ to $\Sigma_o^*$. We define the state-partition complexity of the language $L$, denoted by $spc(L)$, as the smallest number of states in any automaton accepting the language $L$ that is a state-partition automaton with respect to the projection $P$. By Theorem 2, the state-partition complexity of the language $L$ is the number of states of the DFA $P(G) \parallel G$, where $G$ is the minimal incomplete DFA accepting the language $L$.

Now, we give the upper bound on the state-partition complexity of regular languages, and prove that this bound is tight. We omit the proof due to space constraints.

**Theorem 5.** Let $L$ be a language over an alphabet $\Sigma$ accepted by the minimal incomplete DFA $G$ with $n$ states. Let $P$ be a projection from $\Sigma^*$ to $\Sigma_o^*$. Then $spc(L) \le 3n \cdot 2^{n-3}$. $\square$

Finally, we prove that the bound proved in the previous theorem is tight.

**Theorem 6.** For every integer $n \ge 3$, there exists a regular language $L$ accepted by the minimal incomplete DFA $G$ with $n$ states such that $spc(L) = 3n \cdot 2^{n-3}$.

*Proof.* Consider the language $L$ accepted by the DFA $G$ depicted in Fig. 9 and the projection $P$ from $\{a, b, c\}^*$ to $\{a, b\}^*$. We need to prove that all subsets of the state set $\{0, 1, \dots, n-1\}$, except for the sets that contain $n-1$ and do not contain $0$, are states of the automaton $P(G)$. Notice that if $X$ is reachable in $P(G)$ by a string $u$ over $\{a, b\}$ and $q \in X$, then state $q$ is reachable in the automaton $G$ by a string $w$ in $P^{-1}(u)$. This means that $(X, q)$ is a reachable state in the automaton $P(G) \parallel G$ since $(X, q) = (\delta(s, P^{-1}(P(w))), \delta(s, w))$. First, we construct an NFA accepting the language $P(L)$ as shown in Fig. 10. Let us show that all subsets of the state set $\{0, 1, \dots, n-1\}$ containing state 0, as well as all non-empty subsets of the set $\{1, 2, \dots, n-2\}$ are reachable.

The proof is by induction on the size of subsets. Each set $\{i\}$, where $i \le n-2$, is reached from $\{0\}$ by the string $a^i$. Let $2 \le k \le n$. Assume that each
<figure><img src="image_11.png" /><figcaption>Fig. 9. The minimal incomplete DFA G meeting the upper bound $3n \cdot 2^{n-3}$.</figcaption></figure>

subset of size $k-1$, satisfying the above mentioned conditions, is reachable. Let $X = \{i_1, i_2, \dots, i_k\}$, where $0 \le i_1 < i_2 < \dots < i_k \le n-1$, be a subset of size $k$. Consider two cases:

(i) $i_1 = 0$. Take $Y = \{i_j - i_2 - 1 \mid 3 \le j \le k\} \cup \{n-2\}$. Then $Y$ is of size $k-1$ and it does not contain state $n-1$. Therefore, it is reachable by the induction hypothesis. The subset $Y$ goes to $X$ on the string $aab^{i_2-1}$ since we have

$$ 
\begin{align*}
Y &\xrightarrow{a} \{0, n-1\} \cup \{i_j - i_2 \mid 3 \le j \le k\} \\
&\xrightarrow{a} \{0, 1\} \cup \{i_j - i_2 + 1 \mid 3 \le j \le k\} \\
&\xrightarrow{b^{i_2-1}} X.
\end{align*}
$$

(ii) $i_1 \ge 1$. Then $i_k \le n-2$. Take $Y = \{0\} \cup \{i_j - i_1 \mid 2 \le j \le k\}$. Then the subset $Y$ is of size $k$ and contains state 0. Therefore, it is reachable as shown in case (i). The subset $Y$ goes to $X$ on the string $a^{i_1}$.

This proves the reachability of all $3 \cdot 2^{n-2} - 1$ subsets of the automaton $P(G)$. The number of all reachable pairs $(X, q)$ with $q \in X$ of the automaton $P(G) \parallel G$ is $\sum_{i=0}^{n-1} \binom{n-1}{i} (i+1) + \sum_{i=0}^{n-2} \binom{n-2}{i} i = 3n \cdot 2^{n-3}$, which proves the theorem. $\square$

<figure><img src="image_12.png" /><figcaption>Fig. 10. An NFA for language $P(L(G))$, where $G$ is shown in Fig. 9.</figcaption></figure>
# 6 Conclusions and Discussion

We investigated deterministic state-partition automata with respect to a given projection. The state set of such an automaton is partitioned into disjoint subsets that are reachable in the projected automaton. Using a result from the literature that every regular language has a state-partition automaton with respect to a given projection, we provided the construction of the minimal state-partition automaton for a regular language and a projection. We also described a regular language and two projections such that no automaton accepting this language is a state-partition automaton with respect to both projections.

Next, we studied closure properties of state-partition automata under the standard constructions of deterministic automata for the operations of complement, union, intersection, concatenation, star, reversal, cyclic shift, and left and right quotients. We showed that except for the right quotient and complement of complete deterministic automata, all other constructions fail to preserve the property of being a state-partition automaton.

Finally, we defined the notion of the state-partition complexity of a regular language as the smallest number of states of any state-partition automaton with respect to a given projection accepting the language. We proved that the tight bound on the state-partition complexity of a language represented by an incomplete deterministic automaton with $n$ states is $3n \cdot 2^{n-3}$. To prove the tightness of this bound, we used a language defined over the ternary alphabet $\{a, b, c\}$ and the projection from $\{a, b, c\}^*$ to $\{a, b\}^*$. Note that it follows from the results of [6] that this bound cannot be reached using a smaller alphabet or a projection to a singleton.

State-partition complexity of regular operations may be investigated in the future. We only know that state-partition complexity of a language and its complement differs by one in the case of complete deterministic automata, and by $3n$ if the automata are incomplete. Defining nondeterministic state-partition automata and investigating their properties may also be of interest.

**Acknowledgements.** We wish to thank Jan Komenda, Klaus Schmidt, and Jan H. van Schuppen for a discussion on state-partition automata.

# References

1. Boutin, O., Komenda, J., Masopust, T., Schmidt, K., van Schuppen, J.H.: Hierarchical control with partial observations: Sufficient conditions. In: Proc. of IEEE Conference on Decision and Control and European Control Conference (CDC-ECC 2011). pp. 1817–1822. Orlando, Florida, USA (2011)

2. Cassandras, C.G., Lafortune, S.: Introduction to discrete event systems. Springer, second edn. (2008)

3. Cho, H., Marcus, S.I.: On supremal languages of classes of sublanguages that arise in supervisor synthesis problems with partial observation. Mathematics of Control, Signals, and Systems 2, 47–69 (1989)
4. Cho, H., Marcus, S.I.: Supremal and maximal sublanguages arising in supervisor synthesis problems with partial observations. Theory of Computing Systems 22(1), 177–211 (1989)

5. Hopcroft, J.E., Motwani, R., Ullman, J.D.: Introduction to automata theory, languages, and computation. Addison-Wesley, Boston (2003)

6. Jirásková, G., Masopust, T.: On a structural property in the state complexity of projected regular languages. Theoretical Computer Science 449C, 93–105 (2012)

7. Jirásková, G., Okhotin, A.: State complexity of cyclic shift. RAIRO – Theoretical Informatics and Applications 42(2), 335–360 (2008)

8. Komenda, J., Masopust, T., Schmidt, K., van Schuppen, J.H.: (2011), personal communication

9. Komenda, J., Masopust, T., van Schuppen, J.H.: Synthesis of controllable and normal sublanguages for discrete-event systems using a coordinator. Systems & Control Letters 60(7), 492–502 (2011)

10. Komenda, J., Masopust, T., van Schuppen, J.H.: Supervisory control synthesis of discrete-event systems using a coordination scheme. Automatica 48(2), 247–254 (2012)

11. Komenda, J., van Schuppen, J.H.: Supremal normal sublanguages of large distributed discrete-event systems. In: Proc. of International Workshop on Discrete Event Systems (WODES 2004). pp. 73–78. Reims, France (2004)

12. Komenda, J., van Schuppen, J.H.: Modular control of discrete-event systems with coalgebra. IEEE Transactions on Automatic Control 53(2), 447–460 (2008)

13. Rabin, M.O., Scott, D.: Finite automata and their decision problems. IBM Journal of Research and Development 3(2), 114–125 (1959)

14. Rozenberg, G., Salomaa, A. (eds.): Handbook of Formal Languages, vol. 1–3. Springer (1997)

15. Sakarovitch, J.: A construction on finite automata that has remained hidden. Theoretical Computer Science 204(1-2), 205–231 (1998)

16. Salomaa, A.: Formal languages. Academic Press, New York (1973)

17. Schmidt, K., Breindl, C.: Maximally permissive hierarchical control of decentralized discrete event systems. IEEE Transactions on Automatic Control 56(4), 723–737 (2011)

18. Schmidt, K., Moor, T., Perk, S.: Nonblocking hierarchical control of decentralized discrete event systems. IEEE Transactions on Automatic Control 53(10), 2252–2265 (2008)

19. Sipser, M.: Introduction to the theory of computation. PWS Publishing Company, Boston (1997)

20. Wong, K.: On the complexity of projections of discrete-event systems. In: Proc. of Workshop on Discrete Event Systems (WODES 1998). pp. 201–206. Cagliari, Italy (1998)

21. Wong, K., Wonham, W.: Hierarchical control of discrete-event systems. Discrete Event Dynamic Systems: Theory and Applications 6(3), 241–273 (1996)

22. Wonham, W.M.: Supervisory control of discrete-event systems (2011), lecture notes, University of Toronto, [Online]. Available http://www control.utoronto.ca/DES/

23. Yu, S.: Regular languages. In: Handbook of Formal Languages, vol. I, pp. 41–110. Springer (1997)

24. Zhong, H., Wonham, W.M.: On the consistency of hierarchical supervision in discrete-event systems. IEEE Transactions on Automatic Control 35(10), 1125–1134 (1990)