Decision Problems for Regular Languages

---

---

Decision Problems are those problems that can be answered with a simple "yes" or "no." In computer science, we see these problems very often because they help us determine specific properties of languages and automata. Finite Automata (FA) are a type of finite state machine. FA can only memorize a finite amount of information; they are limited to answering decision problems that require only a finite amount of memory.

In this chapter, we will see various decision problems related to Regular Expressions (RE) and Finite Automata (FA). We will use straightforward language and examples to explain these concepts for easy understanding.

Membership Problem

The first decision problem we consider is whether a string x belongs to a regular expression R. This problem is known as the membership problem.

Explanation

A regular expression R can be converted to an equivalent finite automaton M. To check if a string x belongs to the regular expression R, we apply x to M. If M reaches its final state upon processing x, then x belongs to R; otherwise, it does not.

Example

Consider the regular expression R = (a | b)^* a. The equivalent finite automaton M will accept strings that end in 'a'. If we take the string x = "bba", applying this string to M will lead M to its final state. Hence, x belongs to R.

Emptiness Problem

The next problem is determining whether the language set of an FA M is empty, i.e., whether L(M) = ∅.

Explanation

An FA does not accept any string if it does not have any final state or if its final state is inaccessible. To determine whether L(M) = ∅ we calculate the set of states S_k reached from the beginning state q₀ upon applying a string of length k. If there is no final state among the reachable states, then L(M) = ∅ otherwise, L(M) ≠ ∅.

Example

Consider an FA M with states q₀, q₁, q₂ where q₂ is the final state, but there is no path from q₀ or q₁ to q₂. Since the final state is inaccessible, L(M) = ∅.

3. Finiteness Problem

The third problem is to determine whether the language set of an FA is finite, i.e., whether L(M) is finite.

Explanation

Using the pumping lemma, we can say that for an FA to accept a string of length ≥n (where n is the number of states of the FA), it must traverse at least one loop. The language accepted by an FA is finite if the length of the accepted strings is less than n.

Example

Consider an FA M with 3 states. If the length of accepted strings is less than 3, then L(M) is finite. If there exists a string that causes the FA to loop, making the string length greater than or equal to 3, L(M) is infinite.

Intersection Problem

The fourth problem is determining whether there exists any string accepted by two FAs M₁ and M₂.

Explanation

This problem is decidable by constructing an FA M that accepts the intersection of the languages of M₁ and M₂. Then, we apply the emptiness problem to M. If L(M) = ∅, then no such string exists; otherwise, a common string does exist.

Example

Suppose M₁ accepts all strings that end in 'a' and M₂ accepts all strings that start with 'a'. The intersection L(M₁) ∩ L(M₂) will accept strings that start and end with 'a'. If there is at least one such string, say "aa", it is accepted by both M₁ and M₂.

Subset Problem

The fifth problem involves checking whether the language set of one FA M₁ is a subset of the language set of another FA M₂, i.e., whether L(M₁) ⊆ L(M₂).

Explanation

To solve this problem, we construct an FA M that accepts the difference L(M₁) - L(M₂). Then, we apply the emptiness problem to M. If L(M) = ∅, then L(M₁) ⊆ L(M₂).

Example

Let M₁ accept all strings over the alphabet {a, b} and M₂ accept all strings that end in 'b'. Clearly, L(M₁) is not a subset of L(M₂) because there are strings in L(M₁) that do not end in 'b', and hence not in L(M₂).

Equality Problem

The sixth problem checks whether two FAs M₁ and M₂ accept the same language, i.e., whether L(M₁) = L(M₂).

Explanation

To determine if two FAs M₁ and M₂ accept the same language, we construct two FAs: one M that accepts L(M₁) - L(M₂) and another M' that accepts L(M₂) - L(M₁). We then apply the emptiness problem to both M and M'. If both languages are empty, i.e., L(M) = ∅ and L(M') = , then L(M₁) = L(M₂).

Example

Suppose M₁ accepts all strings that end in 'a' or 'b', and M₂ accepts all strings over the alphabet {a, b}. The languages L(M₁) and L(M₂) are not the same because M₂ accepts all strings, whereas M₁ only accepts strings that end in 'a' or 'b'. Hence, L(M₁) ≠ L(M₂).

Regular Expression Equivalence Problem

The seventh problem is whether two regular expressions R₁ and R₂ represent the same language set.

Explanation

This problem can be reduced to the equality problem discussed earlier. First, convert both regular expressions R₁ and R₂ into their equivalent finite automata M₁ and M₂. Then, use the method described in the equality problem to check if L(M₁) = L(M₂).

Example

Consider two regular expressions R₁ = (a | b)^* and R₂ = (a | b) (a | b)^*. After converting these into FAs, we see that both M₁ and M₂ accept the same language, which is the set of all strings over the alphabet {a, b}. Therefore, L(R₁) = L(R₂).

Minimal FA Problem

The eighth and final problem involves determining whether a given FA is the minimal state FA for a language L.

Explanation

To solve this, we minimize the given FA M using state minimization techniques and generate a minimized FA M'. If the number of states in M and M' are the same, then M is already minimized; otherwise, it is not. This problem is decidable.

Example

Suppose we have an FA M with 4 states. By applying minimization techniques, we reduce M to an FA M' with 3 states. Since M' has fewer states than M, M was not minimal. The minimized FA M' is the minimal state FA for the language L.

Conclusion

There are many such decision problems available in automata theory but for finite automata, they are limited due to the finite memory size of finite automata. These problems include determining whether a string belongs to a regular expression or not.

In this chapter, we have had a detailed overview of several decision problems for regular languages using simple language and examples.