Question

Write a class for DFA type objects. Deterministic Finite Automata are commonly defined as a quintuple consisting of a set of states, a set of symbals, a transition function, a start state and a set of accept states

class DFA: def __init__(self, alpha, delta, accept): "Constructs a DFA object"!! self.alpha = alpha self.delta = delta self.accept = accept # YOUR CODE HERE def __repr__(self): return DFA with alphabet {}, transition function {} and accept states {}'). format (self.alpha, self.delta, self.accept) def accepts(self, tape): ""Processes the input tape and returns True if it is accepted otherwise False""" # YOUR CODE HERE def comp (self) ""Returns a DFA object that accepts the complement of the language self accepts""" # YOUR CODE HERE Include runs of the following tests in your submission. #odd number of 'a's m = DFA ("ab", [[1,0], [0,1]],{1}) print(m) t = "aaabaaba" print(m.accepts(t))

For this implementation let the alphabet be given as a string of symbols, the transition function as list of lists which represent an n by m matrix where the n rows represent the states and the m columns represent the alphabet symbols, and the accept states as a set. The states are integers 0, 1, 2, ..., n-1 and 0 is the start state. The input tape is a string of symbols from the alphabet.

Answer 1

Answer:

CODE:

class DFA:
    def __init__(self, alpha, delta, accept):
        self.alpha = alpha
        self.delta = delta
        self.accept = accept
    
        #transition is a dictionary storing the transition
        self.transition = {}
        for state in range(len(delta)):
            self.transition[state] = {}
            for alphabet in range(len(delta[state])):
                self.transition[state][alpha[alphabet]] = delta[state][alphabet]

    def __repr__(self):
        return "DFA with alphabet {}, transition {} and accept states {}".format(self.alpha,self.delta,self.accept)

    def accepts(self, tape):
        #as per question, initial state = 0
        present_state = 0
        for x in tape:
            #make a transition for symbol x in tape
            present_state = self.transition[present_state][x]
    
        # if we get present_state as a final state after finishing the tape,
        #then return true othetrwise return false
        if present_state in self.accept:
            return True
        else:
            return False
    
    #In complement of DFA , the final state becomes non-final and non-final become final state
    def comp(self):
        new_final_state = set()
        for i in range(len(self.delta)):
            #make those states final which are not final in current DFA
            if i not in self.accept:
                new_final_state.add(i)
        #return complemented DFA
        return DFA(self.alpha, self.delta, new_final_state)

#odd number of ’a’s
m=DFA("ab",[[1, 0], [0, 1]], {1})
print(m)
t = "aaabaaba"
print(m.accepts(t))

SCREENSHOT OF THE CODE:

class DFA: def init (self, alpha, delta, accept): self.alpha alpha self.delta = delta self.accept = accept #transition is a dictionary storing the transition self. transition = {} for state in range (len (delta)): self. transition[state] = {} for alphabet in range (len (delta[state])): self. transition(state) (alpha(alphabet]] = delta[state] [alphabet] def repr (self): return "DFA with alphabet {}, transition {} and accept states {}".Format (self.alpha, self.delta, self.accept) def accepts (self, tape): #as per question, initial state = 0 present state = 0 for xin tape: #make a transition for symbol x in tape present_state = self.transition (present_state] [x] # if we get present state as a final state after finishing the tape, #then return true othetrwise return false if present_state in self.accept: return True else: return false

#In complement of DFA, the final state becomes non-final and non-final become final state def comp (self): new_final_state = set() for i in range (len (self.delta)): #make those states final which are not final in current DFA if i not in self.accept: new final state.add(i) #return complemented DFA return DFA (self.alpha, self.delta, new_final_state) #odd number of 'a's m=DFA ("ab", [[1, 0], [0, 1]], {1}) print (m) t = "aaabaaba" print (m.accepts (t))

OUTPUT:

>>> DFA with alphabet ab, transition [[1, 0], [0, 1]] and accept states set ([1]) False

Thank you.