Designing Deterministic Finite Automata (Set 8)

Prerequisite:

Designing finite automata

In this article, we will see some designing of Deterministic Finite Automata (DFA).

Problem-1:

Construction of a minimal DFA accepting a set of strings over {a, b} in which the second symbol from left-hand side is always ‘b’.

Explanation:

The desired language will be like:

L1 = {ab, aba, abaa, bb, bb, bbbb, ...........}

Here as we can see that each string of the language containing ‘b’ as the second symbol from left-hand side but the below language is not accepted by this DFA because some of the string of the below language does not contain ‘b’ as the second symbol from the left-hand side.

L2 = {ba, ba, babaaa..............}

This language L2 is not accepted by this required DFA because it does not contain ‘b’ as the second symbol from the left-hand side. The state transition diagram of the desired language will be like below:

In the above DFA, The state ‘W’ is the initial state which on getting either ‘a’ or ‘b’ as the input it transit to a state ‘X’. The state ‘X’ on getting ‘b’ as the input it transits to the final state ‘Y’ and on getting ‘a’ as the input it transit to a dead state ‘Z’. The final state ‘Y’ on getting either ‘a’ or ‘b’ as the input it remains in the state of itself. The dead state ‘Z’ is called dead because it can not go to the final state on getting any of the input alphabets.

Note:

The number of states in the above DFA is (n+2), where ‘n’ is the number from the left-hand side of the string used in the above language.

Problem-2:

Construction of a minimal DFA accepting a set of strings over {a, b} in which the third symbol from left-hand side is always ‘b’.

Explanation:

The desired language will be like:

L1 = {aab, baba, aabaa, bbb, abb, bbbb, ...........}

Here as we can see that each string of the language containing ‘b’ as the third symbol from left-hand side but the below language is not accepted by this DFA because some of the string of the below language does not contain ‘b’ as the third symbol from the left-hand side.

L2 = {baa, aba, baabaaa..............}

This language L2 is not accepted by this required DFA because it does not contain ‘b’ as the third symbol from the left-hand side. The state transition diagram of the desired language will be like below:

In the above DFA, The state ‘V’ is the initial state which on getting either ‘a’ or ‘b’ as the input it transits to the state ‘W’. The state ‘W’ is a state which on getting either ‘a’ or ‘b’ as the input it transits to a state ‘X’. The state ‘X’ on getting ‘b’ as the input it transits to the final state ‘Y’ and on getting ‘a’ as the input it transit to a dead state ‘Z’. The final state ‘Y’ on getting either ‘a’ or ‘b’ as the input it remains in the state of itself. The dead state ‘Z’ is called dead because it can not go to the final state on getting any of the input alphabets.

Code Solution:

This Python code defines a minimal DFA with three states (q0, q1, and q2). The accepting state is q2, and the transition function is defined according to the condition that the third symbol from the left must be ‘b’. The process_string method checks if a given string is accepted by the DFA. The example then tests the DFA with a list of strings and prints whether each string is accepted or not.

Python3

class DFA:
    def __init__(self):
        # Define the states
        self.states = {'q0', 'q1', 'q2'}

        # Define the alphabet
        self.alphabet = {'a', 'b'}

        # Set the initial state
        self.current_state = 'q0'

        # Set the accepting state
        self.accepting_state = 'q2'

    def transition(self, state, symbol):
        # Define the transition function
        if state == 'q0':
            if symbol == 'a':
                return 'q1'
            elif symbol == 'b':
                return 'q0'
        elif state == 'q1':
            if symbol == 'a':
                return 'q2'
            elif symbol == 'b':
                return 'q1'
        elif state == 'q2':
            # No transitions from q2
            return 'q2'

        # Default case (should not reach here for a complete DFA)
        return 'error'

    def process_string(self, input_string):
        for symbol in input_string:
            if symbol not in self.alphabet:
                # Symbol not in the alphabet
                return False
            self.current_state = self.transition(self.current_state, symbol)

        # Check if the final state is an accepting state
        return self.current_state == self.accepting_state


def main():
    dfa = DFA()

    # Test strings
    test_strings = ["abab", "bbba", "aab", "baaab"]

    for test_string in test_strings:
        result = dfa.process_string(test_string)
        print(f"String: {test_string} - Accepted: {'Yes' if result else 'No'}")


if __name__ == "__main__":
    main()

OUTPUT:

String: abab – Accepted: Yes

String: bbba – Accepted: Yes

String: aab – Accepted: Yes

String: baaab – Accepted: Yes

Note:

The number of states in the above DFA is (n+2), where ‘n’ is the number from the left-hand side of the string used in the above language.