def test_thompson_letter(self):
     alphabet = {'a', 'b'}
     automaton = thompson(parse_regular_expression('a'), alphabet)
     automaton.draw(name='ThompsonTest.test_thompson_letter').render(
         directory='out/', format='pdf')
     self.assertTrue(automaton.read('a'))
     self.assertFalse(automaton.read('b'))
     self.assertFalse(automaton.read(''))
 def test_brozozwski_minimize(self):
     alphabet = {'a', 'b', 'c', 'd'}
     automaton1 = brozozwski_minimize(
         thompson(parse_regular_expression('abcd'), alphabet)
     )
     automaton1.draw(
         name='BrozozwskiMinimizeTest.test_brozozwski_minimize.automaton1'
     ).render(directory='out/', format='pdf')
     self.assertEqual(len(automaton1.states), 5)
     self.assertTrue(automaton1.read('abcd'))
     self.assertFalse(automaton1.read('a'))
     self.assertFalse(automaton1.read('ab'))
     self.assertFalse(automaton1.read('abc'))
     self.assertFalse(automaton1.read('bcda'))
     self.assertFalse(automaton1.read('dcbaa'))
Example #3
0
    def test_brozozwski(self):

        alphabet = {'a', 'b', 'c'}

        aut1 = FiniteAutomaton(alphabet=alphabet,
                               states={'q0', 'q1'},
                               initial_states={'q0'},
                               accepting_states={'q1'},
                               transitions={'q0': [('a', 'q1')]})
        self.assertEqual(
            repr(brozozwski(aut1)).replace(' ', ''), 'a'.replace(' ', ''))

        aut2 = FiniteAutomaton(alphabet=alphabet,
                               states={'q0', 'q1', 'q2'},
                               initial_states={'q0'},
                               accepting_states={'q2'},
                               transitions={
                                   'q0': [('a', 'q1')],
                                   'q1': [('b', 'q2')]
                               })
        self.assertEqual(
            repr(brozozwski(aut2)).replace(' ', ''),
            'CONCAT(a, b)'.replace(' ', ''))

        aut2 = FiniteAutomaton(alphabet=alphabet,
                               states={'q0', 'q1', 'q2'},
                               initial_states={'q0'},
                               accepting_states={'q2'},
                               transitions={
                                   'q0': [('a', 'q1'), ('c', 'q2')],
                                   'q1': [('b', 'q2')]
                               })
        aut2_bro = brozozwski(aut2)
        aut2_rec = thompson(aut2_bro, alphabet)
        self._compare(aut2, aut2_rec, ['', 'a', 'b', 'c', 'ab', 'abc'])

        aut3 = FiniteAutomaton(alphabet=alphabet,
                               states={'q0', 'q1', 'q2'},
                               initial_states={'q0'},
                               accepting_states={'q2'},
                               transitions={
                                   'q0': [('a', 'q0'), ('b', 'q1')],
                                   'q1': [('c', 'q2')]
                               })
        aut3_bro = brozozwski(aut3)
        aut3_rec = thompson(aut3_bro, alphabet)
        self._compare(aut3, aut3_rec, ['', 'a', 'b', 'c', 'ab', 'abc', 'aaab'])

        aut4 = FiniteAutomaton(alphabet=alphabet,
                               states={'q0', 'q1', 'q2'},
                               initial_states={'q0'},
                               accepting_states={'q0'},
                               transitions={
                                   'q0': [('a', 'q1')],
                                   'q1': [('a', 'q2')],
                                   'q2': [('a', 'q0')]
                               })
        aut4_bro = brozozwski(aut4)
        aut4_rec = thompson(aut4_bro, alphabet)
        self._compare(
            aut4, aut4_rec,
            ['', 'a', 'b', 'c', 'aa', 'aab', 'aaa', 'aaaa', 'aaaaaa'])