コード例 #1
0
    def test_automata_union(self):
        q0 = State("q0")
        q1 = State("q1")
        states = {q0, q1}
        alphabet = {'a', 'b'}
        automaton1 = FiniteAutomaton(states, alphabet, q0, {q1})
        automaton1.insert_transition(q0, 'a', q1)
        automaton1.insert_transition(q0, 'b', q1)
        automaton1.insert_transition(q1, 'a', q0)
        automaton1.insert_transition(q1, 'b', q0)
        #L(M) = {x|x in (a,b)* ^ |x| is odd}
        s0 = State("s0")
        s1 = State("s1")
        states = {s0, s1}
        alphabet = {'a', 'b'}
        automaton2 = FiniteAutomaton(states, alphabet, s0, {s0})
        automaton2.insert_transition(s0, 'a', s1)
        automaton2.insert_transition(s0, 'b', s1)
        automaton2.insert_transition(s1, 'a', s0)
        automaton2.insert_transition(s1, 'b', s0)
        #L(M) = {x|x in (a,b)* ^ |x| is even}

        union = automaton1.union(automaton2)

        self.assertTrue(automaton1.recognize_sentence("abaab"))
        self.assertTrue(automaton2.recognize_sentence("ababba"))
        self.assertFalse(automaton1.recognize_sentence("ababba"))
        self.assertFalse(automaton2.recognize_sentence("abaab"))
        self.assertTrue(union.recognize_sentence("abaab"))
        self.assertTrue(union.recognize_sentence("ababba"))
        self.assertFalse(union.recognize_sentence("abc"))
コード例 #2
0
    def test_insert_false_transition(self):
        q0 = State("q0")
        q1 = State("q1")
        alphabet = {'a', 'b'}
        automaton = FiniteAutomaton({q0}, alphabet, q0, {q0})

        self.assertRaises(Exception, automaton.insert_transition, q0, 'c', q0)
        self.assertRaises(Exception, automaton.insert_transition, q0, 'a', q1)
コード例 #3
0
    def test_insert_transition(self):
        q0 = State("q0")
        q1 = State("q1")
        automaton = FiniteAutomaton({q0, q1}, {'a'}, q0, set())

        automaton.insert_transition(q0, 'a', q1)

        self.assertTrue(automaton.has_transition(q0, 'a', q1))
コード例 #4
0
    def test_is_automata_completely_defined(self):
        q0 = State("q0")
        q1 = State("q1")
        automaton = FiniteAutomaton({q0, q1}, {'a', 'b'}, q0, {q1})
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q1, 'a', q0)

        self.assertFalse(automaton.is_completely_defined())
コード例 #5
0
    def test_minimization_on_the_automaton_language_epsilon_word(self):
        q0 = State("q0")
        q1 = State("q1")
        epsilon_word = FiniteAutomaton({q0, q1}, set(), q0, {q1})
        epsilon_word.insert_transition(q0, '&', q1)

        epsilon_word.minimize()

        self.assertTrue(epsilon_word.recognize_sentence(""))
コード例 #6
0
    def test_is_the_empty_language(self):
        q0 = State("q0")
        q1 = State("q1")
        q2 = State("q2")
        q3 = State("q3")
        automaton = FiniteAutomaton({q0, q1, q2, q3}, {'a', 'b'}, q0, {q3})
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q1, 'b', q2)
        automaton.insert_transition(q3, 'a', q2)

        self.assertTrue(automaton.is_empty())
コード例 #7
0
    def test_add_nondeterministic_transition(self):
        q0 = State("q0")
        q1 = State("q1")
        automaton = FiniteAutomaton({q0, q1}, {'a', 'b'}, q0, {q1})
        automaton.insert_transition(q0, 'a', q0)
        automaton.insert_transition(q1, 'b', q1)

        automaton.insert_transition(q0, 'a', q1)

        self.assertTrue(automaton.is_nondeterministic())
        self.assertTrue(automaton.has_transition(q0, 'a', q0))
        self.assertTrue(automaton.has_transition(q0, 'a', q1))
コード例 #8
0
    def test_remove_unreachable_states(self):
        q0 = State("q0")
        q1 = State("q1")
        q2 = State("q2")
        states = {q0, q1}
        alphabet = {'a', 'b'}
        automaton = FiniteAutomaton(states, alphabet, q0, {q1})
        automaton.insert_transition(q0, 'a', q1)

        automaton.remove_unreachable_states()

        self.assertSetEqual(automaton._states, {q0,q1})
コード例 #9
0
    def test_recognize_sentence_with_epsilon_transition(self):
        q0 = State("q0")
        q1 = State("q1")
        q2 = State("q2")
        automaton = FiniteAutomaton({q0, q1, q2}, {'a', 'b'}, q0, {q2})
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q1, 'a', q0)
        automaton.insert_transition(q1, '&', q2)
        automaton.insert_transition(q2, 'b', q2)

        self.assertTrue(automaton.recognize_sentence("aaab"))
        self.assertTrue(automaton.recognize_sentence("aaaaabbbbbbbb"))
        self.assertFalse(automaton.recognize_sentence("aaaabbb"))
コード例 #10
0
    def test_rename_all_states(self):
        q0 = State("q0")
        q1 = State("q1")
        q2 = State("q2")
        automaton = FiniteAutomaton({q0, q1, q2}, {'a', 'b'}, q0, {q1, q2})
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q1, 'b', q2)
        automaton.insert_transition(q1, '&', q2)

        automaton.rename_states()

        self.assertTrue(automaton.recognize_sentence("ab"))
        self.assertFalse(automaton.recognize_sentence("b"))
コード例 #11
0
    def test_change_state_name(self):
        q0 = State("q0")
        q1 = State("q1")
        evena = FiniteAutomaton({q0, q1}, {'a', 'b'}, q0, {q0})
        evena.insert_transition(q0, 'b', q0)
        evena.insert_transition(q0, 'a', q1)
        evena.insert_transition(q1, 'b', q1)
        evena.insert_transition(q1, 'a', q0)

        evena._change_state_name(q0, "q2")

        self.assertTrue(evena.recognize_sentence("bbabaabba"))
        self.assertTrue(evena.recognize_sentence("aaaa"))
        self.assertFalse(evena.recognize_sentence("abbabaabbab"))
コード例 #12
0
    def test_intersection_disjoint_languages(self):
        q0 = State("q0")
        q1 = State("q1")
        evena = FiniteAutomaton({q0, q1}, {'a', 'b'}, q0, {q0})
        evena.insert_transition(q0, 'b', q0)
        evena.insert_transition(q0, 'a', q1)
        evena.insert_transition(q1, 'b', q1)
        evena.insert_transition(q1, 'a', q0)

        empty = evena.intersection(evena.complement())

        empty.minimize()

        self.assertTrue(empty.is_empty())
コード例 #13
0
    def test_remove_transition(self):
        q0 = State("q0")
        q1 = State("q1")
        automaton = FiniteAutomaton({q0, q1}, {'a', 'b'}, q0, {q1})
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q0, 'b', q1)
        automaton.insert_transition(q1, 'a', q0)
        automaton.insert_transition(q1, 'b', q0)

        automaton.remove_transition(q0, 'a', q1)

        self.assertFalse(automaton.has_transition(q0, 'a', q1))
        self.assertTrue(automaton.has_transition(q0, 'b', q1))
        self.assertTrue(automaton.has_transition(q1, 'a', q0))
コード例 #14
0
    def test_recognize_true_sentence(self):
        q0 = State("q0")
        q1 = State("q1")
        states = {q0, q1}
        alphabet = {'a', 'b'}
        automaton = FiniteAutomaton(states, alphabet, q0, {q1})
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q0, 'b', q1)
        automaton.insert_transition(q1, 'a', q0)
        automaton.insert_transition(q1, 'b', q0)
        #L(M) = odd sized sentences

        self.assertFalse(automaton.is_nondeterministic())
        self.assertTrue(automaton.recognize_sentence("aba"))
コード例 #15
0
    def test_remove_equivalent_states(self):
        q = []
        for i in range(0, 6):
            q.append(State("q" + str(i)))
        states = set(q)
        alphabet = {'a', 'b'}
        automaton = FiniteAutomaton(states, alphabet, q[0], {q[0], q[5]})
        automaton.insert_transition(q[0], 'a', q[5])
        automaton.insert_transition(q[0], 'b', q[1])
        automaton.insert_transition(q[1], 'a', q[4])
        automaton.insert_transition(q[1], 'b', q[3])
        automaton.insert_transition(q[2], 'a', q[2])
        automaton.insert_transition(q[2], 'b', q[5])
        automaton.insert_transition(q[3], 'a', q[4])
        automaton.insert_transition(q[3], 'b', q[0])
        automaton.insert_transition(q[4], 'a', q[1])
        automaton.insert_transition(q[4], 'b', q[2])
        automaton.insert_transition(q[5], 'a', q[5])
        automaton.insert_transition(q[5], 'b', q[4])
        old = automaton.copy()

        automaton.remove_equivalent_states()

        self.assertTrue(old.recognize_sentence("aaaaaaababba"))
        self.assertTrue(automaton.recognize_sentence("aaaaaaababba"))
        self.assertFalse(old.recognize_sentence("baaaaba"))
        self.assertFalse(automaton.recognize_sentence("baaaaba"))
コード例 #16
0
    def test_recognize_nondeterministic(self):
        q0 = State("q0")
        q1 = State("q1")
        q2 = State("q2")
        q3 = State("q3")
        automaton = FiniteAutomaton({q0, q1, q2, q3}, {'a', 'b'}, q0, {q3})
        automaton.insert_transition(q0, 'a', q0)
        automaton.insert_transition(q0, 'b', q0)
        automaton.insert_transition(q0, 'b', q1)
        automaton.insert_transition(q1, 'a', q2)
        automaton.insert_transition(q2, 'b', q3)
        automaton.insert_transition(q3, 'a', q3)
        automaton.insert_transition(q3, 'b', q3)

        self.assertTrue(automaton.recognize_sentence("abaababaaaba"))
        self.assertFalse(automaton.recognize_sentence("aaaabaaab"))
コード例 #17
0
    def test_automata_subtraction(self):
        q0 = State("q0")
        q1 = State("q1")
        abstar = FiniteAutomaton({q0}, {'a', 'b'}, q0, {q0})
        abstar.insert_transition(q0, 'a', q0)
        abstar.insert_transition(q0, 'b', q0)

        evena = FiniteAutomaton({q0, q1}, {'a', 'b'}, q0, {q0})
        evena.insert_transition(q0, 'b', q0)
        evena.insert_transition(q0, 'a', q1)
        evena.insert_transition(q1, 'b', q1)
        evena.insert_transition(q1, 'a', q0)

        subtraction = abstar - evena

        self.assertTrue(subtraction.recognize_sentence("babbbaba"))
        self.assertTrue(subtraction.recognize_sentence("a"))
        self.assertFalse(subtraction.recognize_sentence("abababa"))
コード例 #18
0
    def test_minimize_empty_complement_automaton(self):
        q0 = State("q0")
        q1 = State("q1")
        evena = FiniteAutomaton({q0, q1}, {'a', 'b'}, q0, {q0})
        evena.insert_transition(q0, 'b', q0)
        evena.insert_transition(q0, 'a', q1)
        evena.insert_transition(q1, 'b', q1)
        evena.insert_transition(q1, 'a', q0)

        complement = evena.complement()

        intersection = evena.intersection(complement)

        intersection = intersection.complement()

        intersection.minimize()

        self.assertFalse(intersection.is_empty())
コード例 #19
0
    def test_minimize_automaton(self):
        q0 = State("q0")
        q1 = State("q1")
        q2 = State("q2")
        q3 = State("q3")
        automaton = FiniteAutomaton({q0, q1, q2, q3}, {'a', 'b'}, q0, {q0, q2})
        automaton.insert_transition(q0, 'b', q2)
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q1, 'b', q1)
        automaton.insert_transition(q1, 'a', q2)
        automaton.insert_transition(q2, 'b', q2)
        automaton.insert_transition(q2, 'a', q3)
        automaton.insert_transition(q3, 'b', q3)
        automaton.insert_transition(q3, 'a', q2)

        automaton.minimize()

        self.assertSetEqual(automaton._states, {q0, q1})
        self.assertTrue(automaton.recognize_sentence("baabaabaababab"))
コード例 #20
0
    def test_remove_state(self):
        q0 = State("q0")
        q1 = State("q1")
        q2 = State("q2")
        states = {q0, q1, q2}
        alphabet = {'a', 'b'}
        automaton = FiniteAutomaton(states, alphabet, q0, {q1})
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q0, 'b', q2)
        automaton.insert_transition(q1, 'a', q0)
        automaton.insert_transition(q1, 'b', q2)
        automaton.insert_transition(q2, 'a', q0)
        automaton.insert_transition(q2, 'a', q1)

        automaton.remove_state(q1)

        self.assertFalse(automaton.has_transition(q0, 'a', q1))
        self.assertFalse(automaton.has_transition(q1, 'a', q0))
        self.assertTrue(automaton.has_transition(q0, 'b', q2))
        self.assertSetEqual(automaton._states, {q0, q2})
コード例 #21
0
    def test_automaton_complement(self):
        q0 = State("q0")
        q1 = State("q1")
        q2 = State("q2")
        alphabet = {'a', 'b'}
        automaton = FiniteAutomaton({q0, q1, q2}, alphabet, q0, {q0})
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q0, 'b', q0)
        automaton.insert_transition(q1, 'b', q1)
        automaton.insert_transition(q1, 'a', q2)
        automaton.insert_transition(q2, 'b', q2)
        automaton.insert_transition(q2, 'a', q0)
        #L(M) = {x | x in (a,b)* ^ #a's is divisible by 3}

        complement = automaton.complement()

        self.assertTrue(automaton.recognize_sentence("baabbababaabb"))
        self.assertFalse(automaton.recognize_sentence("abbabababbba"))
        self.assertTrue(complement.recognize_sentence("abbabababbba"))
        self.assertFalse(complement.recognize_sentence("baabbababaabb"))
コード例 #22
0
    def test_equality_2(self):
        q0 = State("q0")
        q1 = State("q1")
        evena = FiniteAutomaton({q0, q1}, {'a', 'b'}, q0, {q0})
        evena.insert_transition(q0, 'b', q0)
        evena.insert_transition(q0, 'a', q1)
        evena.insert_transition(q1, 'b', q1)
        evena.insert_transition(q1, 'a', q0)
        q2 = State("q2")
        q3 = State("q3")
        amod4 = FiniteAutomaton({q0, q1, q2, q3}, {'a', 'b'}, q0, {q0})
        amod4.insert_transition(q0, 'b', q0)
        amod4.insert_transition(q0, 'a', q1)
        amod4.insert_transition(q1, 'b', q1)
        amod4.insert_transition(q1, 'a', q2)
        amod4.insert_transition(q2, 'b', q2)
        amod4.insert_transition(q2, 'a', q3)
        amod4.insert_transition(q3, 'b', q3)
        amod4.insert_transition(q3, 'a', q0)

        self.assertFalse(evena.is_equal(amod4))
コード例 #23
0
    def test_automata_equality(self):
        q0 = State("q0")
        q1 = State("q1")
        q2 = State("q2")
        q3 = State("q3")
        automaton = FiniteAutomaton({q0, q1, q2, q3}, {'a', 'b'}, q0, {q0, q2})
        automaton.insert_transition(q0, 'b', q2)
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q1, 'b', q1)
        automaton.insert_transition(q1, 'a', q2)
        automaton.insert_transition(q2, 'b', q2)
        automaton.insert_transition(q2, 'a', q3)
        automaton.insert_transition(q3, 'b', q3)
        automaton.insert_transition(q3, 'a', q2)

        evena = FiniteAutomaton({q0, q1}, {'a', 'b'}, q0, {q0})
        evena.insert_transition(q0, 'b', q0)
        evena.insert_transition(q0, 'a', q1)
        evena.insert_transition(q1, 'b', q1)
        evena.insert_transition(q1, 'a', q0)

        self.assertTrue(evena.is_equal(automaton))
コード例 #24
0
    def test_automaton_intersection(self):
        q0 = State("q0")
        q1 = State("q1")
        states = {q0, q1}
        alphabet = {'a', 'b'}
        automaton = FiniteAutomaton(states, alphabet, q0, {q0})
        automaton.insert_transition(q0, 'a', q1)
        automaton.insert_transition(q0, 'b', q1)
        automaton.insert_transition(q1, 'a', q0)
        automaton.insert_transition(q1, 'b', q0)
        #L(M) = {x|x in (a,b)* ^ |x| is even}
        other = FiniteAutomaton(states, alphabet, q0, {q0, q1})
        other.insert_transition(q0, 'a', q0)
        other.insert_transition(q0, 'b', q1)
        other.insert_transition(q1, 'a', q0)
        #L(M) = {x|x in (a,b)* ^ bb not in x}

        intersection = automaton.intersection(other)

        self.assertTrue(automaton.recognize_sentence("aabaab"))
        self.assertTrue(other.recognize_sentence("aabaab"))
        self.assertTrue(intersection.recognize_sentence("aabaab"))
        self.assertFalse(intersection.recognize_sentence("abbaaa"))
コード例 #25
0
    def test_automata_union_2(self):
        q0 = State("q0")
        q1 = State("q1")
        states = {q0, q1}
        alphabet = {'a', 'b'}
        automaton = FiniteAutomaton(states, alphabet, q0, {q0, q1})
        automaton.insert_transition(q0, 'a', q0)
        automaton.insert_transition(q0, 'b', q1)
        automaton.insert_transition(q1, 'a', q0)
        #L(M) = {x|x in (a,b)* ^ bb not in x}
        q2 = State("q2")
        other = FiniteAutomaton({q0, q1, q2}, alphabet, q0, {q0, q1, q2})
        other.insert_transition(q0, 'a', q0)
        other.insert_transition(q0, 'b', q1)
        other.insert_transition(q1, 'a', q0)
        other.insert_transition(q1, 'b', q2)
        other.insert_transition(q2, 'a', q0)
        #L(M) = {x|x in (a,b)* ^ bbb not in x}

        union = automaton.union(other)

        self.assertTrue(union.recognize_sentence("baababa"))
        self.assertFalse(union.recognize_sentence("aaababbbaaba"))
コード例 #26
0
    def test_determinize_automaton(self):
        q0 = State("q0")
        q1 = State("q1")
        q2 = State("q2")
        q3 = State("q3")
        automaton = FiniteAutomaton({q0, q1, q2, q3}, {'a', 'b'}, q0, {q3})
        automaton.insert_transition(q0, 'a', q0)
        automaton.insert_transition(q0, 'b', q0)
        automaton.insert_transition(q0, 'b', q1)
        automaton.insert_transition(q1, 'a', q2)
        automaton.insert_transition(q2, 'b', q3)
        automaton.insert_transition(q3, 'a', q3)
        automaton.insert_transition(q3, 'b', q3)
        #{x|x in (a,b)* and bab in x}
        determinized = automaton.copy()

        determinized.determinize()

        self.assertTrue(automaton.is_nondeterministic())
        self.assertFalse(determinized.is_nondeterministic())
        self.assertTrue(determinized.recognize_sentence("abaaababbbaaaab"))
        self.assertTrue(determinized.recognize_sentence("baaaaaabbbbbbbbabbaaaaaa"))
        self.assertFalse(determinized.recognize_sentence("aaaabaabaabaabaab"))
コード例 #27
0
    def test_remove_dead_states(self):
        q = []
        for i in range(0, 6):
            q.append(State("q" + str(i)))
        states = set(q)
        alphabet = {'a', 'b'}
        automaton = FiniteAutomaton(states, alphabet, q[0], {q[2]})
        automaton.insert_transition(q[0], 'a', q[1])
        automaton.insert_transition(q[0], 'b', q[3])
        automaton.insert_transition(q[1], 'a', q[2])
        automaton.insert_transition(q[1], 'b', q[2])
        automaton.insert_transition(q[3], 'a', q[5])
        automaton.insert_transition(q[4], 'a', q[3])
        automaton.insert_transition(q[5], 'a', q[4])

        automaton.remove_dead_states()

        self.assertSetEqual(automaton._states, {q[0], q[1], q[2]})
コード例 #28
0
    def test_insert_state(self):
        automaton = FiniteAutomaton(set(), set(), State(""), set())

        automaton.insert_state(State("q0"))

        self.assertEqual(1, automaton.state_quantity())
コード例 #29
0
    def to_finite_automaton(self):
        """Retorna o resultado da conversão da Gramática para um NDFA
        @return Automato resultante
        """
        # get initial state as the initial symbol
        initial_state = State(self._initial_symbol)
        # create a 'final' state that will get the productions that go just for a terminal
        # as "A->a" or "A->b"
        final_state = State('final')

        # sets for the states and final states
        states = set()
        final_states = set()

        # add the initial and 'final' states to the sets
        states.add(initial_state)
        states.add(final_state)
        final_states.add(final_state)

        # dict that translates a nonterminal to a state, and add the initial state on it
        nonterminals_states = dict()
        nonterminals_states[self._initial_symbol] = initial_state

        # gather states and final states from the existing productions
        for production in self._productions:
            # verify that there is a state for certain nonterminal(on the left)
            # otherwise create it, and add to the states set and dict
            if production._left not in nonterminals_states:
                new_state = State(production._left)
                states.add(new_state)
                nonterminals_states[production._left] = new_state

            # if the nonterminal have a epsilon production, than its state is final
            # as "A->&" or "B->&"
            if production._right == '&':
                state = nonterminals_states[production._left]
                final_states.add(state)

        #print("initial_state",initial_state)
        #print("states",states)
        #print("final_states",final_states)
        #print("nonterminals_states",nonterminals_states)

        # create a ndfa from the states, terminals, initial state and final states gathered above
        ndfa = FiniteAutomaton(states, self._terminals, initial_state, final_states)

        # create the transitions from the productions
        for production in self._productions:
            # get the state correspondent to the nonterminal(on the left)
            state = nonterminals_states[production._left]

            # if the production is in the format "A->a", "A->b"
            # its state gonna have a transition to the 'final' state by its terminal
            if production._right in self._terminals:
                ndfa.insert_transition(state, production._right, final_state)
                #print(production._left, '--', production._right, '->', '[F]')
            # if the production is in the format "A->A", "A->B" ## PS: its not regular ##
            # its state gonna have a transition by epsilon to the other's state
            elif production._right in self._nonterminals:
                other_state = nonterminals_states[production._right]
                ndfa.insert_transition(state, '&', other_state)
                #print(production._left, '--', '&', '->', production._left)
            # if the production is in the format "A->aA", "A->aB"
            # its state gonna have a transition by the terminal to the other nonterminal's state
            elif production._right[0] in self._terminals and production._right[1] in self._nonterminals:
                other_state = nonterminals_states[production._right[1]]
                ndfa.insert_transition(state, production._right[0], other_state)
                #print(production._left, '--', production._right[0], '->', production._right[1])

        # determinize the ndfa and return it
        # ndfa.determinize()
        return ndfa
コード例 #30
0
 def test_all_alphabet_members_are_one_character_only(self):
     q0 = State("q0")
     self.assertRaises(Exception, FiniteAutomaton, {q0}, {'b', 'ab'}, q0, {q0})