gico de Aerona

utica
Instituto Tecnolo

CT-200
Fundamentos de Automata e Linguagens Formais
(Prof. Paulo Tasinaffo)

Seminario 1:
An n log n Algorith for Minimizing States in a Finite
Automata, (J.H. Hopcroft, 1971)

Grupo:
Marcello Costa
Melina Nihari
Silvio Assuncao

Sao Jose dos Campos, 7 de Abril de 2016

ii

SUMARIO
Pagina
1 Introducao . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.1

CONTEXTO HISTORICO
. . . . . . . . . . . . . . . . . . . . . . . . . .

1.2

IMPORTANCIA
CIENTIFICA . . . . . . . . . . . . . . . . . . . . . . .

1.3

SOBRE O AUTOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.4

RESUMO DO ARTIGO . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.4.1

Introducao . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.4.2

Descricao formal do Algoritmo . . . . . . . . . . . . . . . . .

1.4.3

Resultados e conclusao . . . . . . . . . . . . . . . . . . . . .

2 Base Sobre Automato Finito Determinstico . . . . . . . . . . . . . . . .

2.1

ESTADOS EQUIVALENTES E MINIMO DFA . . . . . . . . . . . . . .

2.2

DE DFA . . . . . . . . .
ALGORITMO CLASSICO
DE MINIMIZAC
AO

3 Algoritmo de Hopcroft . . . . . . . . . . . . . . . . . . . . . . . . . . . .

11

3.1

TESTE EXPERIMENTAL EM PYTHON . . . . . . . . . . . . . . . . .

13

4 Consideracoes Finais . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

18

REFERENCIAS
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

19

1. INTRODUC
AO
O problema de se eleborar algoritmos eficientes para encontrar o mnimo automato
determinstico finito equivalente para um dado automato pode ser tracado desde os
anos 1950s com os trabalhos de Huffman1 e Moore2 . Durante varios anos algoritmos
alternativos foram propostos. No entanto, no pior caso de analise, esses algoritmos
demandavam n2 processos, onde, n e o n
umero de estados. Hopcroft introduziu em
1971 um algoritmo O(n log n) para minimizacao de DFA de n estados. A constante
de proporcionalidade depende linearmente do n
umero de smbolos de entrada. Claramente o mesmo algoritmo pode ser usado para determinar se dois automatos sao
equivalentes. Este trabalho e o resultado da pesquisa sobre tal artigo de Hopcoft,
intitulado: An n log n Algorithm for Minimizing States in a Finite Automaton [1].
O relatorio esta divido nas seguintes partes: No Captulo 1 e apresentada uma introducao, a importancia cientifica do artigo, a bibiografia do autor e um resumo
do artigo original. No Captulo 2, e realizada uma revisao dos conceitos basicos de
DFAs para se estabelecer as regras de minimizacao exploradas pelo algoritmo classico
anterior ao de Hopcroft. No capitulo 3, o Algoritmo de Hopcroft e formalmente descrito e sao realizados testes em linguagem Python. Finalmente, no Captulo 4 sao
apresentadas algumas consideracoes finais sobre este estudo.

Huffman - David Albert Huffman (1925-1999 Ohio USA. premios: W. Wallace McDowell (1973),
Medalha Richard W. Hamming (1999).
2
Moore - Edward Forrest Moore (1925-2003), Baltimore, Maryland USA - professor americano de
Matem
atica e Ciencia da Computacao, inventor da maquina de Moore.

2
1.1

CONTEXTO HISTORICO

A inquietacao de encontrar um algoritmo para reduzir um Automato Finito Determinstico (DFA), isto e, encontrar um processo com menos ou mnimos estados,
remonta aos primordios do estudo da teoria da computacao, desde a decada de 50,
com Huffman e Moore. Porem, esse algoritmo proposto por Hopcroft, nesse Artigo
de 1971 publicado no Departamento de Ciencia da Computacao da Universidade de
Stanford, introduz um eficiente modelo, com complexidade k.n log n, onde k e uma
constante com crescimento linear e n e o n
umero de estados do automato, reduzindo
significativamente a complexidade dos anteriores que estavam na ordem n2 . E alem
disso, ainda resolve o problema computacional de verificar eficientemente, se dois
automatos sao equivalentes.
Os Automatos Finitos Determinsticos sao uma tupla (Q, , , q0 , F ) onde: Q e o
conjunto de estados; e o alfabeto, isto e, o conjunto de smbolos de entrada; sao as
transicoes onde sao consumidas os smbolos da entrada, inseridos como sequencias de
smbolos, denominados strings ou palavras; q0 e o subconjunto de Q definidos como
estados iniciais; e, F sao os estados de aceitacao da entrada strings.
Portanto, a minimizacao de estados proposto por Hopcroft alem de reduzir a
quantidade de estados da representacao do automato, ainda minimiza o tempo computacional.
No processo de reducao ha tres estados ou classes que podem ser removidos:
Estados inalcancaveis, nao sao possveis de alcancar atraves de qualquer cadeia; os
Estados Mortos ou de armadilha, isto e, todo estado que ao ser atingido, permanece
nele independente da entrada; e por u
ltimo os indistintos entre si para qualquer cadeia,
os mais difceis de serem encontrados e o u
ltimo passo nas minimizacoes.

1.2

IMPORTANCIA
CIENT
IFICA

O estudo de formas de simplificacao resolve varias questoes do estudo de linguagens, como descobrir se uma determinada linguagem e regular, atraves da utilizacao de

3
outras mais simplificadas, como tambem definir se dois automatos definem a mesma
linguagem. Ao minimizar estados, podemos reduzir custos o tamanho dos circuitos de
comutacao, implantam fisicamente os automatos atraves de circuitos eletricos, diminuindo por exemplo a area que o chip ocupa. Apesar desse estudo ser da decada de
70, ainda hoje existem trabalhos relacionados ao assunto, exemplificando ainda mais
o assunto, bem como denotando que ainda ha espaco para exploracao.

1.3

SOBRE O AUTOR

John E. Hopcroft(Seatle, EUA - 1939)

e professor de Engenharia e Matematica
Aplicada em Ciencia da Computacao na
Universidade de Cornell desde 1972. Oriundo de uma famlia de trabalhadores, seu
pai, britanico, foi veterano da Primeira
Guerra Mundial, que se mudou apos a
guerra para o Canada atras de emprego,
mas acabou em Seattle. Onde John cursou a graduacao em Engenharia Eletrica,
formando-se em Seattle em 1961 [2].
Apesar de ninguem da sua famlia possuir graduacao, foi incentivado a estudar e
a se esforcar para adquirir conhecimentos, estudou e recebeu o ttulo de mestrado em
1962, e de doutorado em 1964, ambos em Engenharia Eletrica em Stanford, e passou
tres anos na Universidade de Princeton, como Professor Assistente e desde 1972, foi
lecionar na Cornell University.
Tornou-se um engenheiro da computacao quase por acaso, quando seu departamento solicitou ao mesmo que lecionasse ciencia da computacao, assunto o qual nao
possuia nenhum conhecimento, necessitando que criasse o curso para os primeiros
seis alunos. E a partir de entao, se apaixonou pela area, lecionando por diversos anos

4
seguintes. Um dos primeiros alunos foi Jeff Ullman, coautor no seu livro mais famoso:
Introducao `a Teoria de Automatos e Linguagens Formais, ed. Campus (Brasil).
Realizou pesquisas em aspectos teoricos da computacao, especialmente em Analise
de Algoritmos e Teoria de Automatos. Coautor de 4 livros sobre Linguagens Formais
e Algoritmos com J. D. Ullman e A.V. Aho, seus dois alunos de pos-graduacao.
Foi agraciado com o A. M. Turing Premio em 1986, com Tarjan por fundamen membro da National
tos em desenho e analise de algoritmos e estrutura de dados. E
Academy of Science (NAS), the National Academy Engineering (NAE), the American
Academy of Arts and Sciences (AAAS), the American Association for the Advancement of Science, the Institute of Electrical and Electronics Engineers (IEEE), and
the Association of Computing Machinery (ACM) [3].
Em 2013 foi ao Brasil onde palestrou no Rio de Janeiro, na Pontifcia Universidade
Catolica-RJ, no Instituto Nacional de Matematica Pura e Aplicada - IMPA-RJ, e
na Universidade de Sao Paulo USP sobre: Future Directions in Computer Science
Research [4].

1.4

RESUMO DO ARTIGO

1.4.1

Introduc
ao

Uma grande quantidade de estudos sobre a minimizacao de automatos ja foi realizada, porem com a complexidade da ordem de n2 em relacao ao n
umero de estados
(n). Nesse estudo e demonstrado um n log n assintoticamente, no pior caso.
Em geral os algoritmos anteriores primeiramente particionavam os estados de
acordo com suas sadas (output). Os blocos de repeticoes sao repetidamente refinados, examinando-se o estado sucessor de uma entrada para cada estado no bloco.
Ate quando nao pudesse mais ser dividido o bloco, concluindo que os estados nos
mesmos blocos sao equivalentes. Porem com n2 passos para a execucao. O algoritmo
proposto nesse trabalho tambem requer n iteracoes, mas que somadas atingem no
maximo n log n vezes.

5
1.4.2

Descric
ao formal do Algoritmo

Sendo A = (S, I, d, F ) onde S sao os estados finitos, I sao as entradas, d sao

as transicoes de S I, em S e F sao o conjunto final de estados, contidos em S
e considerados de aceitacao. A denominao I e o conjunto de strings ou todas as
sequencias de smbolos de I. Estados t e s sao considerados equivalentes se para cada
x em I , d(s, x) esta em F se somente se d(t, x) esta em F . Todos esses passos sao
descritos no Algoritmo 1. Considerando que no final do algoritmo, dois estados sao
equivalentes, se e somente se, eles estiverem no mesmo bloco.

1.4.3

Resultados e conclus
ao

Para obter os dados de tempo, o algoritmo foi aplicado em duas classes de automatos
finitos. Na primeira classe foi dado A(n) = ({1, 2, 3, . . . , n}, {0, 1}, , {1}) onde (1, 1) =
1, (0, 1) = i 1 e (i, 1) = i para 2 i n. Automatos da segunda classe sao
dados, para cada estado n por B(n) = ({1, 2, 3..., n}, {0, 1}, , {i|1 i n/2})
onde (i, 0) = (i, 1) = n/2 + 2i1 e (n/4 + i, 1) = 2i 1 para 1 i n/4 e
(n/2 + i, 0) = (n/2 + i, 1) = 2i 1 para n/2 < i n/4.
Foi demonstrado entao que A(n) que requeria anteriormente n2 passos, com esse
processamento ele cresce linearmente com o n
umero de estados crescente, e em B(n)
mostra um crescimento n.logn para ambos os algoritmos, o anterior e o apresentado
nesse trabalho. Demonstrando que esse algoritmo e pratico para o objetivo de minimizar os automatos finitos (ou ainda para testar a equivalencia de automatos finitos)
para mais de milhares de estados.

6
Algorithm 1 Algoritmo de Hopcroft
Step 1: s S e a I construa
1 (S, a) = {t|(t, a) = s}
Step 2: construa B(1) = F , B(2) = S F e para cada a em I e 1 i 2 construa
a(i) = {S|s B(i) e 1 (s, a) 6= }
Step 3: faca k = 3
Step 4: a I construa

L(a) =

{1}

se |a(1)| |a(1)|

{2}

caso contrario

Step 5: Seleciona a em I e i em L(a). O algoritmo termina quando L(a) = para

cada a em I.
Step 6: Apaga i de L(a).
Step 7: j < k faca B(j) com s(t, a) a(i) realizar os steps 7a, 7b,a7c e 7d.
0

00

Step 7a: Particao B(j) dentro de B (j) = {t|s(t, a) a(i)} e B (j) = B(j)B (j).
0

00

Step 7b: Substitua B(j) por B (j) e construa B(k) = B (j). Construa o correspondente a(j) e a(k) para cada a em I.
Step 7c: a I modica L(a) como segue:

L(a) =

L(a) {j}

se j 3 L(a) e 0 < |a(j)| |a(k)|

L(a) {k}

caso contrario

Step 7d: faca k = k + 1.

Step 8: volta para o Step 5.

2. BASE SOBRE AUTOMATO

FINITO
DETERMINISTICO
Nesta secao sao apresentados teoremas e definicoes preliminares sobre automatos determinsticos tratados em [5]. A partir desta base e possvel construir as regras para
a minimizacao de automatos finitos.
Define-se como Automato Finito um modelo matematico de um sistema com entradas e sadas discretas que aceita uma linguagem regular com um n
umero particular
de estados. Formalmente, tem-se a definicao:
Definic
ao 2.1 Um Automato Finito Determinstico D e uma tupla (Q, , , q0 , F ),
onde:
Q e um conjunto finito de estados;
e o alfabeto de entrada;
: Q Q e a funcao de transicao;
q0 e o estado inicial;
F Q e o conjunto de estados finais.
Outras definicoes preliminares basicas sao apresentadas a seguir.
Definic
ao 2.2 String: Qualquer sequencia finita de smbolos justapostos pertencentes
a um alfabeto.
a, b, c (smbolos) abc (string) .
Definic
ao 2.3 linguagem: Conjunto de todos os strings sobre um alfabeto fixo

8
= {a}, logo, = {, a, aa, aaa, . . . }
Dessa forma, conclui-se que, uma linguagem aceita pelo automato D, L(D), e o
conjunto de todas os strings w tais que, (q0 , w) F .

ESTADOS EQUIVALENTES E M
INIMO DFA

2.1

A condicao de equivalencia de DFAs estabelece a ponte para a minimizacao

dos mesmos, dessa forma, sao apresentadas as seguintes definicoes que implicam na
condicao essencial para minimizacao explorada pelos algoritmos de minimizacao de
DFA.
sao equivalentes se e somente se L(D) = L(D)

Definic
ao 2.4 Dois DFAs D and D
Definic
ao 2.5 Um DFA e considerado mnimo se nao existir outro DFA equivalente
com menos estados.
Como consequencia das Deficoes 2.4 e2.5, existe um metodo u
nico de se encontrar
0

o mnimo DFA D equivalente a um dado um DFA D, considerando-se:

Equivalente p q tal que (p, x) e (q, x) F
Distinguvel p 6= q tal que (p, x) e (q, x) 3 F

2.2

DE DFA
ALGORITMO CLASSICO
DE MINIMIZAC
AO

A estrategia de minimizacao neste algoritmo e baseada na remocao dos estados

inacessveis (distinguveis) e na obtencao das classes de equivalencias para formar os
estados de um novo DFA.
Portanto, no DFA M = (Q, , , q0 , F ), p distinguvel de q se e, somente se a
entrada correspondente ao par (p, q) e marcada (removida).
= L(A) e A e
Teorema 2.1 O algoritmo de minimizacao esta correto quando L(A)
mnimo.

9
Teorema 2.2 O tempo de execucao do algoritmo e O(n2 ).
O processo de minimizacao segue o metodo de preenchimento da tabela descrito
nas Figuras 2.1 e 2.2, detalhadamente apresentado no Captulo 3 de [5]. Dessa forma,
obtem-se o algoritmo 2 que repete o processo de busca de estados distinguveis a
fim de remove-los ate restarem somente os estados nao distinguveis para compor
oautomato minimizado.

Algorithm 2 Algoritmo classico de minimizacao de DFA.

1:

Requer: um DFA A

2:

Garante: o mnimo automato A equivalente A

3:

Remove os estados inacessveis

4:

Marca todos os pares p, q, onde p F e q 3 F

5:

repeat

6:
7:
8:
9:
10:
11:
12:

for all pares nao marcados p, q do

for all smbolo a do
if o par (p, a), (q, a) e marcado then
marca p, q
end if
end for
end for

13:

until nenhum par marcado

14:

Constroi o automato reduzido A

10

DFA Original

1
0
b X

Incio

1
1

X X X

g X X X X

h X

X X X

d X X

c X X

X X

X X X X X
b

a e, b h, d f

Estados Equivalentes:

Fig. 2.1.: Processo de Minimizacao DFA de 6 estados usando preenchimento de

Tabela.

DFA Reduzido

Incio

[a, e]
0

0
[b, h]

1
0

[g]

0
1

1
1
[c]

[d, f]

Fig. 2.2.: DFA minimizado pelo processo de preenchimento de tabela, realizado pelo
algoritmo claassico.

11

3. ALGORITMO DE HOPCROFT
O Algoritmo de Hopcroft pode ser formalmente descrito pelos seguintes Lemas e
Definicoes [6].
Lema 3.1 Seja D = (Q, , , q0 , F ) e a serie i (i 0) de relacoes de equivalencia
sobre Q, definida com:

0 =

{(p, q)|p, q F } {(p, q)|p, q Q F }

(3.1)

i+1 = {(p, q) i |(a )((p, a), (q, a)) i }

e, tendo que
0 0 . . .
Se i = i+1 entao i = j para todo i > j
Existe 0 k |Q| tal que k = k+1 .
Pode-se, dessa forma, considerar a situacao onde i 6= i+1 ,

1 6= i+1

(p, q Q, a ) p, q i e((p, a), (q, a)) 3 i

(U Q|i , a ) p, q U e((p, a), (q, a)) 3 i

(U, V Q|i , a ) p, q U e(p, a) V e(q, a) 3 V

(U, V Q|i , a ) (U, a) 6= e (U, a) V

(3.2)

E, recorrendo ao Lema 3.1, a relacao equivalente sobre D pode ser calculada pelo
algoritmo 3:

12
Algorithm 3 Computacao das relacoes de equivalencia usando refinamentos.
1:

Q| {F, Q F }

2:

while (U, V Q|, a ) s.t. Eq. 3.2 e mantida do

Q| (Q| {U }) {U 1 (V, a), U U 1 (V, a)}

3:
4:

end while

Dessa forma, deve-se decidir de forma eficiente como encontrar uma tripla U, V, a
para a qual a Eq. 3.2 seja mantida.
Lema 3.2 Seja D = (Q, , , q0 , F ) e U Q|. Supondo o refinamento de U dentro
0

00

de U e U . Entao, para qualquer a , o refinamento de todas as classes de com

0

00

relacao a (U , a) e (U , a) conduz ao mesmo resultado como no refinamento de em

0

00

relacao a (U, a), (U , a) e (U , a).

Lema 3.3 Seja D = (Q, , , q0 , F ), Q| = {F, Q F } e a . Then refining
with respect to either (F, a) or (Q F, a) yields the same result as refining with
respect to both of them.
Os Lemas 3.2 e 3.3 fornecem a possibilidade de reducao de calculo que pode ser
explorado recursivamente no Algoritmo de Hopcroft, definido a seguir.
Definic
ao 3.1 Seja U = {U1 , U2 , . . . , Um }(1 m |Q|) o conjunto de todas as
classes criadas no algoritmo de minimizacao, entao

|U| =

m
X

|Ui | |Q|log|Q|

(3.3)

i=1

Definic
ao 3.2 Para este algoritmo o tempo de execucao e O(n log n).
A partir dos Lemas e das definicoes abordados, e possvel descrever o processo
de execucao de minimizacao do algoritmo proposto por Hopcroft, atraves do pseudocodigo apresentado no algoritmo 4.

13
Algorithm 4 Algoritmo de Hopcroft.
1:

W {F, Q F }

2:

P {F, Q F }

3:

while w nao e vazio do

4:

seleciona e remove S de W

5:

for all a do

6:

la 1 (S, a)

7:

for all R pertence a P tal que R la 6= e R la do

8:

particiona R em R1 e R2 : R1 R la and R2 R R1

9:

substitui R em P com R1 e R2

10:
11:
12:
13:

if R W then
substitui R em W com R1 e R2
else
if |R1 R2 | then
adiciona R1 a W

14:
15:

else
adiciona R2 a W

16:
17:
18:
19:

end if
end if
end for

20:

end for

21:

end while

3.1

TESTE EXPERIMENTAL EM PYTHON

Os codigos em Python apresentados a seguir implementam o Algoritmo de Hopcroft

descrito pelo pseudo-codigo do algoritmo 4. Sao realizadas minimizacoes sobre tres
diferentes DFAs (df a 01 com 8 estados, df a 02 com 5 estados e df a 03 com 6 esta-

14
dos). Os resultados de minimizacao sao definidos pela funcao mindf a 01, mindf a 02
e mindf a 03, respectivamente.

1
2
3
4
5
6
7

def get_start_final(dfa):
print "start state: "
print dfa.get_start_state()
print "final state: "
print dfa.get_final_states()
print "transitions: "
get_transitions(dfa)

8
9
10
11
12
13
14
15
16
17
18
19
20
21

get_start_final(dfa_01)
start state:
a
final state:
set([c])
transitions:
[((a, 0), ->, b),
[((c, 1), ->, c),
[((b, 1), ->, c),
[((e, 0), ->, h),
[((g, 0), ->, g),
[((f, 1), ->, g),
[((h, 1), ->, c),

((a,
((c,
((b,
((e,
((g,
((f,
((h,

1),
0),
0),
1),
1),
0),
0),

->,
->,
->,
->,
->,
->,
->,

f)]
a)]
g)]
f)]
e)]
c)]
g)]

22
23
24
25
26
27
28
29
30
31
32
33

get_start_final(mindfa_01)
start state:
(a, e)
final state:
set([(c,)])
transitions:
[(((f,), 0), ->, (c,)), (((f,), 1), ->, (g,))]
[(((c,), 1), ->, (c,)), (((c,), 0), ->, (a, e))]
[(((h, b), 1), ->, (c,)), (((h, b), 0), ->, (g,))]
[(((g,), 1), ->, (a, e)), (((g,), 0), ->, (g,))]
[(((a, e), 1), ->, (f,)), (((a, e), 0), ->, (h, b))]

34
35
36
37
38
39
40

get_start_final(dfa_02)
start state:
1
final state:
set([1, 5])
transitions:

15
41
42
43
44
45

[((1,
[((3,
[((2,
[((5,
[((4,

b),
a),
b),
b),
a),

->,
->,
->,
->,
->,

2),
5),
1),
2),
4),

((1,
((3,
((2,
((5,
((4,

a),
b),
a),
a),
b),

->,
->,
->,
->,
->,

3)]
4)]
4)]
3)]
4)]

46
47
48
49
50
51
52
53
54
55
56

get_start_final(mindfa_02)
start state:
(1, 5)
final state:
set([(1, 5)])
transitions:
[(((3,), a), ->, (1, 5)), (((3,), b), ->, (4,))]
[(((4,), a), ->, (4,)), (((4,), b), ->, (4,))]
[(((2,), b), ->, (1, 5)), (((2,), a), ->, (4,))]
[(((1, 5), b), ->, (2,)), (((1, 5), a), ->, (3,))]

57
58
59
60
61
62
63
64
65
66
67
68
69

get_start_final(dfa_03)
start state:
1
final state:
set([1, 2, 5, 4, 6])
transitions:
[((1, b), ->, 3), ((1,
[((3, a), ->, 3), ((3,
[((2, b), ->, 4), ((2,
[((5, b), ->, 3), ((5,
[((4, a), ->, 6), ((4,
[((6, b), ->, 4), ((6,

a),
b),
a),
a),
b),
a),

->,
->,
->,
->,
->,
->,

2)]
3)]
2)]
5)]
3)]
5)]

70
71
72
73
74
75
76
77
78
79
80
81
82

get_start_final(mindfa_03)
start state:
(1,)
final state:
set([(6,), (4,), (1,), (2,), (5,)])
transitions:
[(((4,), a), ->, (6,)), (((4,), b),
[(((1,), b), ->, (3,)), (((1,), a),
[(((6,), b), ->, (4,)), (((6,), a),
[(((3,), a), ->, (3,)), (((3,), b),
[(((2,), b), ->, (4,)), (((2,), a),
[(((5,), b), ->, (3,)), (((5,), a),

->,
->,
->,
->,
->,
->,

(3,))]
(2,))]
(5,))]
(3,))]
(2,))]
(5,))]

16
A seguir sao apresentados os testes de validacao de strings em cada DFA (original
e minimizado) para verificar a equivalencia:

1
2
3
4
5
6
7
8
9
10

#DFA01:
input1=01001111100111111111
mindfa_01.process_input(input1)
(c,)
dfa_01.process_input(input1)
c
mindfa_01.is_input_accepted(input1)
True
dfa_01.is_input_accepted(input1)
True

11
12
13
14
15
16
17
18
19
20

input2 = 0101
dfa_01.process_input(input2)
f
mindfa_01.process_input(input2)
(f,)
dfa_01.is_input_accepted(input2)
False
mindfa_01.is_input_accepted(input2)
False

21
22
23
24
25
26
27
28
29
30
31

#DFA02:
input3=ababbbaaa
dfa_02.process_input(input3)
4
mindfa_02.process_input(input3)
(4,)
dfa_02.is_input_accepted(input3)
False
mindfa_02.is_input_accepted(input3)
False

32
33
34
35
36
37
38
39
40

input4=aabbaabb
dfa_02.process_input(input4)
1
mindfa_02.process_input(input4)
(1, 5)
dfa_02.is_input_accepted(input4)
True
mindfa_02.is_input_accepted(input4)

17
41

True

42
43
44
45
46
47
48
49
50
51
52

#DFA03:
input5=ababababa
dfa_03.process_input(input5)
6
mindfa_03.process_input(input5)
(6,)
dfa_03.is_input_accepted(input5)
True
mindfa_03.is_input_accepted(input5)
True

53
54
55
56
57
58
59
60
61
62

input6=ababb
dfa_03.process_input(input6)
3
mindfa_03.process_input(input6)
(3,)
dfa_03.is_input_accepted(input6)
False
mindfa_03.is_input_accepted(input6)
False

Conforme observado nos testes, a minimizacao resultou em DFAs equivalentes.

Dessa forma, possvel alcancar a minimizaca de estados com complexidade O(n log n),
que, no artigo original, foi apontada em testes realizados com a implementacao do
algoritmo em linguagem Algol.

18

4. CONSIDERAC
OES
FINAIS
O problema de minimizacao de DFA e um estudo bem conhecido de linguagens formais. Como pode ser observado no trabalho, Hopcroft desenvolveu um algoritmo
eficiente para a realizacao do processo de minimizacao em comparacao aos algoritmos previamente elaborados. Esse algoritmo consegue estabelecer a complexidade de
tempo em O(M N log2 N ) (onde M e o tamanho do alfabeto e N e o n
umero de
estados).
O algorimo foi testado em Python, onde, foram verificadas a sua capacidade de
equivalencia de DFAs.
minimizacao e de verificacde

19

REFERENCIAS

[1] J. E. Hopcroft, An n log n algorithm for minimizing states in a finite automaton,

tech. rep., Stanford, CA, USA, 1971.
[2] C. University, John E Hopcroft, 2007 (acessado em 20 de marco, 2016). http:
//www.cs.cornell.edu/jeh/.
[3] ACM, John E Hopcroft, 2012 (acessado em 20 de marco, 2016).
amturing.acm.org/award_winners/hopcroft_1053917.cfm.

http://

[4] U. de Sao Paulo, Renomado cientista e pesquisador norte-americano ministra

palestra no IME, 2013 (acessado em 20 de marco, 2016). http://www.usp.br/
aun/exibir.php?id=5006.
[5] J. E. Hopcroft and J. D. Ullman, Introduction To Automata Theory, Languages,
And Computation. Boston, MA, USA: Addison-Wesley Longman Publishing Co.,
Inc., 1st ed., 1990.
[6] X. Yingjie, Describing an nlog n algorithm for minimizing states in deterministic
finite automaton, 2009.