Transition Complexity of Incomplete DFAs

In this paper, we consider the transition complexity of regular languages based on the incomplete deterministic finite automata. A number of results on Boolean operations have been obtained. It is shown that the transition complexity results for union and complementation are very different from the state complexity results for the same operations. However, for intersection, the transition complexity result is similar to that of state complexity.

💡 Research Summary

The paper introduces and studies the notion of transition complexity for regular languages when they are represented by incomplete deterministic finite automata (DFAs). An incomplete DFA is a DFA whose transition function is partial; for some state‑symbol pairs the transition may be undefined. Transition complexity is defined as the total number of defined transitions (i.e., the size of the transition relation). While state complexity—counting the number of states—has been extensively investigated for Boolean operations on regular languages, the authors argue that transition complexity is a more realistic metric for implementation because it directly reflects the size of the transition table and thus memory consumption.

The authors first formalize transition complexity and compare it with the traditional state complexity framework. They then focus on the three basic Boolean operations: union, intersection, and complement. For each operation they derive tight upper and lower bounds on the worst‑case transition complexity, and they provide concrete language families that meet these bounds, thereby proving optimality.

Union.
Given two incomplete DFAs M₁ and M₂ with m₁, m₂ states and k₁, k₂ defined transitions respectively, the standard construction for union uses a product automaton whose state set is Q₁×Q₂ together with two additional “copy” states to handle the case where one component is undefined. Because a transition is defined in the product whenever at least one of the component transitions exists, the number of defined transitions can blow up to Θ(|Σ|·m₁·m₂) in the worst case, where |Σ| is the alphabet size. This is dramatically larger than the state‑complexity bound of m₁+m₂. The paper presents a family of languages (essentially “aⁿb” vs. “aⁿc” over a binary alphabet) that forces every pair of states to have a defined transition for each symbol, showing that the bound is tight. A matching lower bound of Ω(|Σ|·m₁·m₂) is also proved.

Complement.
For complement, the partial nature of the DFA becomes crucial. To obtain a DFA that accepts the complement language, every undefined transition must be redirected to a new dead state. Consequently, the complement automaton always has exactly |Q|·|Σ| defined transitions, regardless of how many were originally present. Thus the transition complexity of complement jumps from k (the original number) to the full product size, which is independent of the original state complexity. The authors highlight that this phenomenon can cause a dramatic increase in memory usage, especially for large alphabets, even though the state complexity of complement remains unchanged (just swapping final and non‑final states).

Intersection.
Intersection behaves more like the classical state‑complexity scenario. The product construction defines a transition only when both component transitions are defined, so the number of defined transitions in the intersection automaton is at most k₁·k₂ and at least Ω(k₁·k₂) in the worst case. Hence the transition complexity of intersection is Θ(k₁·k₂), which mirrors the Θ(m₁·m₂) bound known for state complexity. The paper supplies language families that achieve this bound, confirming that intersection does not cause an unexpected explosion of transitions.

After presenting the theoretical results, the authors discuss practical implications. They propose design guidelines for minimizing transition complexity: keep the original DFAs sparse, avoid unnecessary dead‑state expansions before complement, and exploit the fact that intersection does not increase transition density. They also suggest post‑processing reductions that can eliminate redundant transitions after Boolean operations, thereby shrinking the transition table without altering the recognized language.

Overall, the paper makes a significant contribution by shifting the focus from merely counting states to counting actual transition entries in incomplete DFAs. It demonstrates that for union and complement the transition complexity can be substantially higher than the corresponding state complexity, while for intersection the two measures stay aligned. These insights are valuable for developers of regex engines, model‑checking tools, and any system where finite‑automaton representations are stored explicitly, because they provide a more accurate predictor of memory consumption and guide the construction of more space‑efficient automata.