Two Extensions of Cover Automata

: Deterministic Finite Cover Automata (DFCA) are compact representations of ﬁnite languages. Deterministic Finite Automata with “do not care” symbols and Multiple Entry Deterministic Finite Automata are both compact representations of regular languages. This paper studies the bene-ﬁts of combining these representations to get even more compact representations of ﬁnite languages. DFCAs are extended by accepting either “do not care” symbols or considering multiple entry DFCAs. We study for each of the two models the existence of the minimization or simpliﬁcation algorithms and their computational complexity, the state complexity of these representations compared with other representations of the same language, and the bounds for state complexity in case we perform a representation transformation. Minimization for both models proves to be NP-hard. A method is presented to transform minimization algorithms for deterministic automata into simpliﬁcation algorithms applicable to these extended models. DFCAs with “do not care” symbols prove to have comparable state complexity as Nondeterministic Finite Cover Automata. Furthermore, for multiple entry DFCAs, we can have a tight estimate of the state complexity of the transformation into equivalent DFCA.


Introduction
The concept of Cover Automata was first presented at a conference paper of Câmpeanu et al. at the Workshop on Implementations and Applications of Automata (WIAA) in Rouen (1999) [1,2] when the authors introduced a formal definition of a Deterministic Finite Cover Automaton (DFCA) and a minimization algorithm. A cover language for a language L is a superset L of L. If L is a finite non-empty language, then the length of the longest word in L exists, and we can denote it with a natural number, l. A DFCA for a finite language L is a deterministic finite automaton (DFA) accepting a cover language for L, such that the accepted words that are not in L have their length greater than l.
During the last two decades, several papers used DCFAs for compact representation of finite languages. Other efficient minimization algorithms were also published, for example [3][4][5][6][7][8]. The concept of DFCA was also generalized to the nondeterministic version in a paper presented at AFL 2014 in Szeged by Câmpeanu [9], followed by the journal version [10].
Using nondeterminism, we can reduce the size of the automata recognizing some languages, but minimizing such automata is known to be PSPACE-complete. Therefore, several other intermediate representations of languages that maintain deterministic transitions were proposed. That is why it is a must to study these extensions in case they are applied to cover automata, which we are doing in Section 2. The first extension considered here is to enhance DFCAs with "do not care" symbols, thus obtaining finite cover automata with "do not care" symbols, denoted by -DFCAs, in other words, finite cover automata accepting partial words. Fischer and Paterson introduced partial words in [11] in 1974, and the authors in [12,13] prove that the minimization of finite automata with "do not care" symbols is NP-hard. As emphasized by Professor Solomon Marcus in [14], many researches from other areas studied the same concept, but in a different theoretical setup with different notations. An example of such a paper related to partial words is [15], where the authors show strong connections between graph problems and pattern matching with some of the symbols in the patterns not known. In that paper, the "do not care" symbol denoted here by is denoted by φ. We will prefer the notation because most references use this notation and using a symbol that is not part of any alphabet is easier to identify. Holzer et al. in [16,17] prove that "almost all problems related to partial word automata, such as equivalence and universality, are already PSPACE-complete". Some of their proofs link non-deterministic automata problems with graph theory problems in a similar fashion as it is done in [15]. As such, because the minimization of -DFAs is hard, only the simplification algorithms were developed for these types of finite machines, and an example is presented in [13]. A simplification algorithm will eventually produce an equivalent automaton with less states than the input automaton, but it is not guaranteed to be minimal. In Section 3, we show that the same difficulties found for NFCA's simplification are also present for -DFCAs, even though -DFCAs can be considered a particular simpler class of NFCAs. We show a simplification algorithm for -DFCAs that has a better time complexity than the one presented for -DFAs in [13].
In [12], the authors give an example of automaton having limited nondeterminismthere is only one transition with degree 2 for the same letter-which is hard to minimize. The same argument can be used to prove that finding the minimal finite cover automaton with "do not care" symbols is also a hard problem. We already know that NFCA minimization is NP-hard, and details of why the previous proofs work as well for -DFCAs are presented in Section 3. In the same paper [12], the example of an automaton that is hard to minimize accepts a finite language having all the accepted words of length at most 3. This example is used to show that minimizing multiple entry deterministic automata (MEFA) (When the number k of entries is known, we use the term k-DFA instead of MEFA) is hard. In Section 4, we show that the method with exactly the same construction will also work for Multiple Entry Finite Cover Automata (MEFCA), or k-entry DFCAs (k-DFCA), adding the results on k-entry FA to the previous ones obtained in [18][19][20][21]. In Section 4, we show that for binary alphabets, by transforming a k-DFCA into a minimal DFCA we can reach the upper bound for NFA to DFCA transformation. Moreover, we show that the general bound is reached for the state complexity of this transformation. Section 5 includes future work and a list of open problems, and the conclusions are drawn in Section 6.

Notations
The number of elements of a set T is #T, an alphabet is usually denoted by Σ, and the set of words over Σ is Σ . The length of a word w ∈ Σ is the number of letters of w, and it is denoted by |w|. Thus, if w = w 1 w 2 · · · w k , where w i ∈ Σ, for all 1 ≤ i ≤ k, then |w| = k. In particular, when k = 0, we have a word with no letters, denoted by ε, and |ε| = 0. We also use the following notations: where Q is a finite non-empty set, the set of states, Σ is the alphabet, q 0 ∈ Q is the initial state, F ⊆ Q is the set of final states, and δ : Q × Σ −→ Q is the transition function. In case the transition function δ is a partial function, denoted as δ : Q × Σ • −→ Q, we have a partial DFA. In case δ is defined for all values of s ∈ Q and a ∈ Σ, the DFA is complete. If we do not emphasize that the DFA is partial, then we understand that the DFA is complete. The transition function δ can be extended in a natural way to Q × Σ * as follows: δ(q, ε) = q, δ(q, wa) = δ(δ(q, w), a). For the rest of the paper we denote the extension δ, by δ. If the transition function δ : Q × Σ • −→ Q is a partial function, then the automaton is incomplete; otherwise, it is a complete one. A Nondeterministic Finite Automaton (NFA) is a quintuple A = (Q, Σ, δ, Q 0 , F), where all the elements are the same as for a DFA except, Q 0 ⊆ Q is the set of initial states and the transition function δ, which is now defined as δ : Q × Σ −→ 2 Q . In case of an NFA, for the transition function we have that for w ∈ Σ , δ(Q 0 , w) ⊆ Q, and δ(q, wa) = s∈δ(q,w) δ(s, a). In what follows, we will use the NFA's with only one initial state as it is defined in [22]. For any NFA A = (Q, Σ, δ, Q 0 , F) there is an equivalent NFA , for all s ∈ Q and a ∈ Σ, and δ (q 0 , a) = s∈Q 0 δ(s, a). Using the form for NFA with only one initial state, or initially connected NFAs, simplify most of the definitions and results and the state complexity will differ from the general case by just one state.
For multiple entry automata, we have a quintuple A = (Q, Σ, δ, Q 0 , F), where Q 0 ⊆ Q. In some cases [23], all the states are considered initial states, thus Q 0 = Q, while in most other cases, we consider k-entry DFA so the transition function δ is deterministic and #Q 0 = k [19].
A state s in a finite automaton A is reachable if there is a word w ∈ Σ such that δ(q 0 , w) = s. In case of a k-entry DFA or an NFA, the state q 0 must be one of the initial states. A state s is useful if there exists w ∈ Σ such that δ(s, w) ∩ F = ∅. In case of a deterministic δ, we have that δ(s, w) ∈ F. A sink state or a dead state is a reachable state with all its transitions being self-loops. All states that are not reachable and not useful can be eliminated without changing the language accepted by the automaton. A deterministic automaton with all states reachable and useful, except one sink state, is called a reduced automaton. In the case of nondeterministic automata, an automaton is considered reduced if all its states are both reachable and useful. In what follows, all automata are reduced automata, so they do not have unreachable or unuseful states.
For an alphabet Σ, we can consider a new symbol , called "do not care symbol", which can replace any letter of Σ. Thus, a word w over the alphabet Σ = Σ ∪ { }, will be a partial word if |w| > 0. We say that the word u ∈ Σ is weaker than v ∈ Σ , denoted u v, if |u| = |v| and for all positions i, Let L be a regular language over the alphabet Σ ∪ { }, with σ : Σ −→ 2 Σ a substitution such that σ(a) = {a} for all a ∈ Σ, and σ( ) ⊆ Σ. The regular language L ⊆ Σ is recognized by -DFA, A = (Q, Σ , δ, q 0 , F), if L = L(A). Accordingly, a -DFA A σ = (Q, Σ , δ, q 0 , F) associated with some substitution σ is defined as a DFA that recognizes a partial language L , and it is also associated with the total language σ(L ).
A cover automaton for a finite language L is a DFA recognizing a cover language L such that L = L ∩ Σ ≤l , for l being the length of the longest word in L. An l-NFCA A is a cover automaton for the language L(A) ∩ Σ ≤l , [10,24]. Any DFA A accepting a finite language is a DFCA for L(A) with l = max{|w| | w ∈ L(A)}.
Two words, x and y, are similar with respect to the finite language L, written x ∼ L y, if for every w ∈ Σ ≤l−max{|x|,|y|} , xw ∈ L, whenever yw ∈ L. In this definition, l is the length of the longest words in L. The similarity relation on words is not an equivalence relation, as it is only reflexive, symmetric, and semi-transitive.
If A is a DFCA for the finite language L, we can also define the level of a state as the length of the shortest path from the initial state to that state, that is level A (p) = min{|w| | δ(q 0 , w) = p}. In case of multiple entry DFCAs, a state will have k levels, i.e., level A,i (p) = min{|w| | δ(q 0,i , w) = p}, for all 1 ≤ i ≤ k, and level A (p) = (level A,1 (p), level A,2 (p), . . . , level A,k (p)), where Q 0 = {q 0,1 , . . . , q 0,k }.
In case the NFCA A is understood, we may omit the subscript A, i.e., we write p ∼ q instead of p ∼ A q, also we can write level(p) instead of level A (p).
We consider only non-trivial NFCAs for L, i.e., NFCAs such that level(p) ≤ l for all states p, and with all the states useful and reachable.
We define deterministic and nondeterministic state complexity of a language as: In case of a finite language L, we can also define the cover complexity variants: We have that ncsc(L) ≤ nsc(L) ≤ sc(L), and ncsc(L) ≤ csc(L) ≤ sc(L).
For an automaton A, we say that it is minimal if the number of states of A is equal to its corresponding complexity; therefore, we can have minimal DFAs, NFAs, DFCAs, NFCAs, -DFAs, MEFAs, and MEFCAs. An algorithm which takes an automaton of one of the above types as input and produces a minimal automaton of the same type as output is called a minimization algorithm. In some cases, minimization algorithms are exponential. Therefore, it is worth designing algorithms that will reduce the number of states, but they may not produce a minimal automaton. In that case, we have simplification algorithms that may reduce the number of states of the automaton used as input and produce an equivalent one with possibly fewer states. Simplification algorithms are preferred for cases when their computational complexity is significantly lower than the complexity of a minimization algorithm.
For either minimization or simplification algorithms, the method that is used the most is to merge two or more states into one state in such a way that the recognized language does not change. By merging state p into state q we redirect all incoming transitions to state p to incoming transitions to state q. For outgoing transitions in case of deterministic automata, outgoing transitions from p are lost, but outgoing transitions from q are preserved. In case of nondeterministic automata merging can be done in many different ways. For example, the following definition is in [10] (Definition 3): Definition 2. Let A = (Q, Σ, δ, q 0 , F) be an NFCA for the finite language L. 1.
We say that the state q is weakly mergeable in state p if the automaton is also an NFCA for L. In this case, we write p q.

2.
We say that the state q is strongly mergeable in state p, if the automaton is also an NFCA for L. In this case, we write p q.
By Theorem 3 of [10], if two states are similar, they are also strongly mergeable; therefore, we can reduce the size of that automaton. Next, we analyze two possible extensions of cover automata. One of them is to allow "do not care" symbols, while the other is to add multiple initial states. For these two types of automata, first, we give the new definitions, then we analyze which results hold and which ones need to be adapted to the new concepts.

Cover Automata for Partial Words
A DFCA with "do not care" symbols, written -DFCA, is a cover automaton for the finite language L ⊆ Σ ≤l . Please note that in a -DFA or -DFCA, it is not required to have for every state transitions with "do not-care" symbol . Thus, partial automata are usually presented as incomplete automata, namely, the transitions of "do not care" symbol to a dead state are omitted.
The language recognized by a -DFCA, A, over the extended alphabet where l is the length of the longest accepted word. We need to find the language over the original alphabet Σ, thus we apply a substitution σ : Σ ∪ { } −→ 2 Σ to get σ(L) as the σ-language over Σ , accepted by the -DFCA.
By replacing the "do not care" symbols in a -DFCA with all letters in Σ, the -DFCA becomes a NFCA. Thus, if L is a language accepted by a minimal -DFCA with n states, then the "do not care" state complexity of L is dnccsc(L) = n. Since any DFCA can be also considered a -DFCA, we have that ncsc(L) ≤ dnccsc(L) ≤ dncsc(L) ≤ sc(L).

Cover Automata with "Do Not Care" Symbols
In our study, we only need to see how "do not care" symbols influence state similarity and mergeability of two states, because everything that would be valid for NFCAs would then apply to -DFCAs. For strong mergeability, we always obtain deterministic transitions because we remove some of the states' transitions.
For a transition t = p α → q, p, q ∈ Q, α ∈ Σ , and a substitution σ, we consider , the set of all transitions that can be obtained by substituting the letter α ∈ Σ with σ(α). If A = (Q, Σ , δ, q 0 , F) is a DFCA for L, we can denote by We now define the compatibility of two states in a -DFCA.

the set of all transitions in the automaton
When the substitution σ is understood or in case σ( ) = Σ , it can be omitted and we say that p and q are compatible, respectively, strongly compatible.
In other words, two states are compatible if by applying the substitution of "do not care" symbols for the -transitions, we obtain the same destination states from p and q using the same letters in Σ. A weak merge, in the sense of Definition 2 can be used in case p and q are compatible, but we need to check that this procedure won't change the language. At the same time, two states are strongly compatible if we can take a destination state s and all transitions with all letters to s can be replaced by only one transition using a "do not care" symbol, and all other destinations can be reached by at most one symbol from Σ for all the other transitions originating in p and q.
Thus, by merging state p with state q and considering the set T of consolidated transitions, we can replace transitions in T with transitions T such that 1.
we will have only one transition for each symbol in Σ and 2.
by applying the substitution σ, we get the same consolidating transitions, i.e., σ(T) = σ(T ). This new procedure can be defined for partial DFAs and it corresponds to the strongly merging procedure in Definition 2.
Let us check the time complexity required to: 1.
Decide if two states are strongly compatible, and 2.
Define a method to merge two strongly compatible states.
To decide if two states are strongly compatible, we need to check the following: If for a letter a ∈ Σ, there are at least three distinct states s 1 , s 2 , s 3 , such that (a, If this condition is not satisfied, we cannot replace all the transitions on b ∈ σ( ) to only one of the states s 1 , or s 2 with the "do not care" symbol, and we do not obtain determinism for the transitions in the merged state.
Because #{s | (p a → s) ∈ σ(p α → s), p α → s ∈ ∆} ≤ #Σ , all these steps, 1 to 4, take O(1) time. Of course, for step 4, we may have two choices for the resulting automaton, but either one we choose, it takes constant time to do the merging. In step 4, if we have a transition from state p to state s with a letter a ∈ Σ and a transition from state p to state s with "do not care" symbol , the transition from state p to state s with a letter a ∈ Σ can be absorbed into transition from state p to state s with "do not care" symbol , as it is a redundant transition.
In Figure 1 are depicted all possible cases of merging two strongly compatible states, in case the alphabet is Σ = {a, b}. Remark 1. By strongly merging two states, we may obtain nondeterministic transitions. However, in the case of strongly compatible states, redundant transitions can be absorbed into the do not care symbol obtaining only deterministic ones.
For defining the similarity relation in a -DFCA for two states p and q, we need the states to be similar in the corresponding NFCA, as in Definition 2 of [10].
Hence, we get the following: Definition 4. For a -DFCA A = (Q, Σ , δ, q 0 , F) two states p and q are similar, denoted p ∼ A q, if for all w ∈ Σ ≤l−max{level A (p),level A (q)} and a partial word u such that w ∈ σ(u), there is a partial word v, such that w ∈ σ(v), and we also have that If the two states are strongly compatible and the result of strongly merging them is state p, the second transition will be from p to s and it may overlap with an a or a b transition, or a diamond transition. In this case, we keep just one transition and we drop the transitions on all letters b ∈ Σ from p to s that are overlapping with it, to avoid nondeterminism. In all cases any non-deterministic choice can be avoided by "absorbing" a letter transition into the "do not-care" symbol transition. Lemma 1. Let -DFCA A = (Q, Σ , δ, q 0 , F) be a -DFCA. If two states p and q are similar, then they can be either strongly merged eliminating redundant transitions, if they are strongly compatible, or weakly merged otherwise.
Proof. Let L be the language of partial words accepted by A, L = σ(L) ⊆ Σ the associated finite language, and l the length of the longest words in L. Without any loss of generality, we may assume that level A (p) ≤ level A (q). Let v ∈ Σ ≤l such that δ(q, v) ∈ F, v = αv , α ∈ Σ . It follows that for every word w ∈ σ(v) and any x q ∈ σ(y q ) such that δ(q 0 , y q ) = q and x q w ≤ l, we have that x q w ∈ L. We also have that |x q | ≥ level(q) ≥ level(p).
There is a partial word u, such that w ∈ σ(u) and δ(p, u) ∈ F because p ∼ A q. Thus, by redirecting all transitions from q to p (the weakly merging method), we obtain a new automaton A for which x q w is in the associated language of A .
If we have a word w in the associated language of A , it means that there is a partial word z accepted by A such that w ∈ σ(z). If for every prefix of π of z, δ (q 0 , π) = p, then δ(q 0 , π) = p, and z is accepted by A, therefore w ∈ L.
Hence, the language associated with the automaton A does not change in case we do a weak merging of similar states.
If p and q are strongly compatible, let w = aw , a ∈ σ( ). Thus, either δ (p, a) = δ(q, a), or δ (p, ) = δ(q, a). Consequently, the word x q w is also in the language associated with the automaton A .
If w is in the associated language of A , then there is a partial word z such that w ∈ σ(z). In case δ(q 0 , π) = p for some π with z = πv, because δ (q 0 , z) ∈ F, then δ (p, v) ∈ F and w = xy, y ∈ σ(v).
Since p ∼ A q, for y ∈ σ(v), there is a partial word u, such that y ∈ σ(u), and δ(q, u) ∈ F.
Let us see how we can use the above results to minimize -DFCAs. In Section 2 of [12], the authors show that NFA minimization is NP-hard even in the case when the NFAs recognize finite languages, and they have limited non-determinism, i.e., the automata have at most one non-deterministic transition. Moreover, Corollary 7 on page 208 of [12], states that the minimization problem is NP-hard even if the input is given as a DFA. Their proof is based on the fact that the normal set cover problem is NP-complete [26,27]. Hence, if you consider these sets as paths, which corresponds to words, in an NFA, finding a minimal NFA is equivalent to finding a minimal set cover. For proving it in case of limited nondeterminism, they need a normal set cover B of a set C, i.e., for each c ∈ C, there is a subset B c of B such that c = ∪ X∈B c X the elements in B c are pairwise disjoint. The partition B is separable normal set basis for C if B can be written as a disjoint union of two other non-empty sets B 1 and B 2 such that for each c ∈ C, the subcollection B c contains at most one element of B 1 and at most one element of B 2 . To do that, they use a modified version of a known reduction from vertex cover to normal set basis (Lemma 4 in [28]), showing that the second problem is NP-hard. Using this result, they show that some instances of normal set basis sets in the partition will be pairwise disjoint and you can have just one state with two a-transitions. For (C, s), a separable normal set basis they consider, the language considered is L = {acb | c ∈ C, b ∈ c}, over a growing alphabet All accepted words are of length 3. Therefore, for our case, we can use the same proof in two ways: 1.
Either showing that -DFAs satisfy the conditions of Definition 1 page 201 of [12] and asking that the minimum length of the longest accepted string is at least 3, or 2.
Use the same input as they use and replace the a symbol, that generates the nondeterministic transition, with a "do not care" symbol, so we get a -DFA. In this case, the only change would be that L = {αcb | α ∈ Σ, c ∈ C, b ∈ c}, and we would get several instances of the same problem, only with the first letter changed. Finding a minimal a normal set cover will only involve letters 2 and 3 for all paths from the start state to the final state, therefore, we can follow the same proof, but ignoring the part where they need to show that the minimal finite automaton is not ambiguous-in our case, that's not necessary. One can check that the proof works without any other change for -DFCAs, considering that the length of the longest accepted word is at least l, with l ≥ 3.
It follows that: Therefore, we need to seek simplification algorithms rather than minimization algorithms for -DFCAs. We already know [1,7,24,29] that all minimization algorithms for DFCAs are based on determining all similar states and merge them. For testing the similarity, one method [24,29], is to compute the gap function for two states p and q, where gap(p, q) is the length of the shortest word that will distinguish between the states p and q. For -DFCAs, this means that we need to determine the length of the shortest word w such that: if w ∈ σ(u), u ∈ Σ ≤l−max{level(p),level(q)} , and δ(q, u) ∈ F, then for any partial word v = u, v ∈ Σ ≤l−max{level(p),level(q)} such that w ∈ σ(v), we have that δ(p, v) / ∈ F.
Because the number of transitions from p and q is bounded by #Σ , computing the gap function for a DFCA can be done in constant time for any pair p, q, if we know the gap function for all pairs r, s, such that r = δ(p, α), s = δ(q, β), α, β ∈ Σ .
Two state would be then similar if gap(p, q) ≥ l − max(level(p), level(q). With these observations and the fact that all known minimization algorithms for DFCAs are based on computing the similarity relation, we can modify any of the known minimizing algorithms for DFCAs [1,4,7,29] or l-DFCAs [24], to obtain a simplification algorithm for -DFCAs, without changing their computational complexity. Since the minimization algorithms for DFCAs are at most O(n 4 ) [1,10], for all these simplification algorithms the time complexity will be at most O(n 4 ) as well, which is better than the time complexity of the simplification algorithm proposed in [13]. Accordingly, we have obtained the following result: Theorem 2. For every DFCA minimization algorithm based on merging similar states having the run time complexity of O( f (n)), there is a simplification -DFCA algorithm having the same complexity of O( f (n)).
A language L is σ-minimal partial language for L if for any other language L" such that σ(L") = L, there is no word w ∈ L such we can find x ∈ L" with x is weaker than w and x = w.
For example, L = { a } is σ-minimal partial language for L = {aaa, aab, baa, bab}. Indeed, if L is σ-partial language for L, x ∈ L and w ∈ L are such that x w, then we either have x = or x = w. In the first case, aba ∈ σ(L ) = L and in the second case x = w is false. Therefore, L is a σ-minimal partial language for L.
It must be noted that the simplification algorithm proposed in [13] obtains an approximation of the σ-minimal partial language L for the regular language L, and obtaining this σ-minimal partial language is NP-hard [13]. The cover language L , for the finite language L that we obtain by applying the simplification algorithm, may not be a cover language for the σ-minimal partial language L σ , i.e., L ∩ Σ ≤l = L σ , but it is a σ-partial language that may have a lower state complexity than the original DFCA for L and σ(L ) is a cover language for L, i.e., σ(L ) ∩ Σ ≤l = L. Please note that L σ is the weakest partial language such that σ(L σ ).
The example above shows that it is impossible to obtain a cover language for the σ-partial minimal language that has, at the same time, the minimal cover state complexity. a © 2 a T g g £ £ Figure 2. Automaton A 1 , left, and automaton A 2 , right. L(A 1 ) is a cover language for the σ-minimal partial language for L, and L(A 2 ) is a cover partial automaton for L, where L = {a, b, aa, ab, ba, aaa, aab, aba, abb, baa, bab}.

Multiple Entry DFCAs
For multiple entry DFCAs, we can have two possible flavors of extensions. The first one and the easiest to consider is the same maximum length for all words accepted by the m-DFCA. The second approach is to consider for each initial state a different maximum length. Therefore, we can use the following definition:

Definition 5.
A multiple entry DFCA with m initial states, i.e., an m-DFCA, is a structure A = (Q, Σ, δ, Q 0 , F, Λ), such that Q, Σ, δ, and F are the same as for usual DFCAs, Q 0 is the set of initial states, #Q 0 = m, and Λ = (l 1 , . . . , l m ) is a sequence of m integers representing the maximum accepted length for each initial state. If Q 0 = {q 0,1 , . . . q 0,m } and Λ = (l 1 , l 2 , . . . , l m ), the language accepted by the m-DFCA A is We have the condition The automata A i are subautomata induced by the m-DFCA A.
We observe from the above definition that the set of initial states has the size m. Thus, by replacing the set Q 0 with an m-tuple Q 0 = (q 0,1 , . . . q 0,m ), if we assign two possible lengths to an initial state, it does not change the accepted language. Assume that the initial states q 0,i and q 0,j are the same, i.e., q 0,i = q 0,j . The automaton will then accept all the words of length less than max{l i , l j }, meaning that we can eliminate the one with the lowest maximum length, getting an (m − 1)-DFCA.
In the example given by Björklund and Martens [12], they prove that minimizing m-DFAs is NP-hard, using a construction with a finite language. Because any m-DFA for a finite language is also an m-DFCA, by setting l i to be the length of the longest accepting walk starting at q 0,i , it follows that Theorem 3. Minimizing m-DFCA is an NP-hard problem.
We can reduce the size of m-DFCA efficiently in a similar way to the previous case for partial automata, obtaining a simplified m-DFCA by merging states. To avoid changing the language recognized by an m-DFCA A, the simplest solution is to merge similar states in all the subautomata A i with the corresponding maximum length l i . Any other merge of states will modify at least one of the languages involved, which will not guarantee that their union stays the same as before. Therefore, we can obtain the following definition for similarity in m-DFCAs: Definition 6. Let A = (Q, Σ, δ, Q 0 , F, Λ) be an m-DFCA for the finite language L. Two states p and q are similar if p and q are similar in all cover automata A i = (Q, Σ, δ, q 0,i , F, λ i ), 1 ≤ i ≤ m.
The simplification algorithms for m-DFCAs can be obtained as before by modifying existing DFA-minimization algorithms, therefore in what follows we will focus on state complexity problem, namely, on constructing a minimal DFCA for the same language, and evaluating the state complexity of this transformation.
It is known that for NFA to DFA transformation for finite languages, [30], in case of a binary alphabet, the upperbound is 2 n 2 +1 − 1 if n is even, and 3 · 2 n−1 2 − 1, if n is odd, n being the number of states of the NFA. Moreover, it is reached by the language L m,n = {a, b} ≤m a{a, b} n when n = m, or n = m − 1, so sc(L m−1,m−1 ) = 2 m+1 − 1, and sc(L m,m−1 ) = 3 · 2 m − 1.
Because the length of the longest word is m + n + 1, the minimal nondeterministic finite automaton recognizing this language will have at least m + n + 2 states, while the minimal DFA will have at least m + n + 3 states, [30], Theorem 2. A minimal (m + 1)-DFA for L m,n has the same number of states as the NFA, plus the sink state, therefore, is minimal as a m-DFA. A minimal (m + 1)-DFCA for L m,n has the same number of states as the NFA minus one, because the sink state is similar with state 0, and that is the only possible similarity. We can see that the minimal nondeterministic cover automaton for L m,n has only n + 2 states. For this NFCA for L m,n , the initial state is obtained by merging all the m + 1-entries into one, so a minimal (m + 1)-DFCA must have m states more than the NFCA, that is m + n + 1.
Starting from an m-DFA for a finite language, we can construct an equivalent NFA by observing that there is one initial state q 0,0 with no incoming transition, and for each initial state q 0,i ∈ Q 0 , if δ(q 0,i , a) = s i , we can add the transitions from q 0,0 with a in s i , and we delete the sink state. This way, for the m-DFA to DFA transformation, we obtain the limits for NFA to DFA transformation, but we need to consider the extra sink state for m-DFAs.
Therefore, we just proved the following result: Theorem 4. In case of a binary alphabet, the upperbound for a n-state m-DFCA to DFCA transformation is 2 n−1 2 +1 − 1 if n is odd, and 3 · 2 n−2 2 − 1, if n is even, and the bound is reached. Figure 3 shows a 5-DFA with 11 states for the language L 4,4 . This 5-DFA is a minimal multi-entry DFA. Any nondeterministic finite automaton recognizing L 4,4 must have at least 11 states which is the length of the longest word in L 4,4 plus 1. A DFA, multi-entry or not must have a sink state, because the language is finite, therefore the automaton depicted in Figure 3a is minimal. The corresponding multi-entry DFCA, Figure 3b has the dead state d similar with state 0, so we can reduce the size by one state. The NFCA in Figure 3c recognizes L 4,4 , and it has only 6 states. The general case for L m,n−1 is depicted in Figure 4. The upperbound for m-DFA to DFCA transformation is the same as the NFA to DFCA transformation, but there is one difference. We have to consider that in the m-DFA, we must have one more state as dead state because the language is finite, while in the NFA that state can be eliminated, as it is not useful.

Discussion
This paper investigates the feasibility of extending the definition of cover automata to include the cases when we allow multiple entries or "do not care" symbols. Because both operations induce a degree of nondeterminism, existing minimization algorithms working on DFAs may not give the smallest automaton in the new class, so we need to verify their run time complexity, and their correctness.
The previous automata constructions prove that minimization problems for certain nondeterministic automata are NP-hard. We checked that the same examples could also be used without any significant modification for cover automata. Hence, the results hold. The proof details for these results were omitted, as it can be found in [12] for NFAs and m-DFAs. For cover automata, we only needed to add the "do not care" symbols to substitute one letter in one transition for the first case and to add the maximum length for both cases.
In the previous studies [31,32] on state complexity of partial words DFAs we can find particular classes of languages where minimization bounds can be established. The general case is still open.
I proved that there are simplification algorithms with the same time complexity as existing minimizing DFCA algorithms. I have also computed the state complexity bound for m-DFCA to DFCA transformation.
In the case of DFCAs, the idea was floating around even in the 1960s [33,34], but no formal definition was given until 1998. That is the reason why until 2001, there was no result published on this topic, but several papers followed after the publication of [1]. In this paper, I give the required formal definitions for two DFCA extensions, and I also prove some essential results necessary to start any further investigation.
There are several questions that one may ask; for example, the following questions might be of interest:

7.
Considering multiple lengths for multiple entry DFAs.
The study of state complexity of operations with finite languages represented by finite deterministic automata was started in [35] and later on in [36]. Later on, the state complexity of operations using nondeterministic automata were considered in [5,[37][38][39]. It would be interesting to see where would the state complexity bounds for operations on these extensions that introduce a low level of nondeterminism would fit: closer to the deterministic results or closer to the non-deterministic models.
For each of these extensions, we need to study the following aspects: 1.
Analyze the complexity of the membership problem.

2.
Investigate the existence of complexity of minimization/simplification algorithms. 3.
Find and evaluate the dynamic complexity and state complexity of transforming the new automata model into a known one. 4.
Find bound for state complexity of operations done using the new representation model.

Conclusions
Two extensions are formally defined for the cover automata model of representing finite languages. Fundamental properties of these extensions were checked and proved, followed by the methodology at the end of Section 5. This article also proves that the minimization of -DFCAs and m-DFCAs is NP-hard, and it shows a process for obtaining simplification algorithms based on merging states in Theorem 2. The upper bound for m-DFCA to DFCA transformation is computed and proved in Theorem 4. The Discussion section also includes open problems and future research directions.
Funding: This research received no external funding.