5337 TM 01 P

Jos Joo Gonalves Morais
Obteno de expresses regulares

pequenas a partir de autmatos
finitos
Departamento de Cincia de Computadores

Faculdade de Cincias da Universidade do Porto
2004
Jos Joo Gonalves Morais
Obteno de expresses regulares

pequenas a partir de autmatos
finitos
Tese submetida Faculdade de Cincias da

Universidade do Porto para obteno do grau de Mestre
em Informtica, ramo de Cincia de Computadores
Departamento de Cincia de Computadores

Faculdade de Cincias da Universidade do Porto
2004
minha me
v
Resumo
H dois algoritmos standard para converter um autmato finito numa expresso regular
equivalente, que so o algoritmo de Kleene e o algoritmo da eliminao de estados, que
consiste em eliminar em cada passo um estado e actualizar as transies do autmato de
forma a que a linguagem reconhecida no se altere. O primeiro algoritmo produz, regra
geral, expresses de tamanho superior s produzidas pelo segundo. Na especificao
do segundo algoritmo nada dito quanto ao estado que deve ser eliminado, a no
ser que deve ser diferente de dois estados especiais que no so removveis em passo
algum do algoritmo. A ordem em que os estados so removidos determina o tamanho
da expresso obtida e assim, numa aplicao deste algoritmo sem uma preocupao
com a escolha do estado a ser removido, podem produzir-se expresses de tamanho
muito superior ao de uma expresso de tamanho mnimo obtenvel por este algoritmo
para o autmato em causa.
O problema que nos propomos tratar neste trabalho o de obter, a partir de um

autmato e baseados no algoritmo da eliminao de estados, uma expresso regular
equivalente com o menor tamanho. A soluo por fora bruta para este problema, que
consiste em aplicar o algoritmo em todas as ordens de remoo possveis e escolher de
entre as expresses obtidas uma de menor tamanho, tem complexidade 0(n\), uma
vez que para um autmato com n estados h n! ordens de remoo possveis.
Neste trabalho apresentamos um resultado que caracteriza um tipo de autmatos para

os quais o problema pode ser resolvido de forma eficiente, bem como duas heursticas
que permitem, nos outros casos, uma aproximao em tempo razovel soluo ptima
do problema.
vii
ndice
Resumo vii
1 Introduo 1
1.1 Definies Fundamentais 3
1.1.1 Expresses Regulares 4
1.1.1.1 Medidas de Complexidade de Expresses Regulares . . 5
1.1.1.2 Equivalncia de Expresses Regulares 6
1.1.2 Algumas Noes Elementares da Teoria de Grafos 7
1.1.3 Autmatos Finitos 8
1.1.3.1 Autmatos Finitos Determinsticos 8
1.1.3.2 Autmatos Finitos no Determinsticos 10
1.1.3.3 Autmatos Finitos no Determinsticos com

Transies-e 11
1.1.3.4 Autmatos Finitos Estendidos 11
1.1.4 Autmatos e Grafos 12
1.1.5 Equivalncia dos Modelos Apresentados 13
1.1.6 Autmatos Mnimos 14
1.1.7 Algoritmo da Eliminao de Estados 14
ix
1.1.7.1 Implementao 15
1.1.8 Algoritmo de Kleene 18
1.2 Descrio do Problema 18
2 Autmatos nard 23
2.1 Introduo 23
2.2 Autmatos nard 24
2.3 Implementao 31
2.4 Autmatos de Thompson 35
2.5 Concluses 38
3 Uma heurstica para o caso geral 43
3.1 Pesos 43
3.2 Heurstica 44
3.3 Alguns Resultados Experimentais 45
3.4 Implementao 48
3.5 Concluses 49
4 Uma heurstica para o caso acclico 55
4.1 Motivao 55
4.2 Heurstica 56
4.3 Exemplo 62
4.4 Alguns Resultados Experimentais 65
4.5 Implementao 67
4.6 Concluses 71
x
5 Concluses 75
Referncias 79
ndice de Tabelas 83
ndice de Figuras 85
Lista de Acrnimos 89
ndice Remissivo 91
A Cdigo 93
A.l FAtoRatExpX 93
A.2 NardFAtoRatExp 99
A.3 FAtoRatExp 107
A.4 AcyclicFAtoRatExp 111
xi
Captulo 1
Introduo
A teoria de linguagens formais uma rea fundamental da cincia de computadores.

Aquilo a que hoje se chama teoria de linguagens formais tem diversas origens, entre as
quais alguns problemas de combinatria e de lgebra de semigrupos. Outra rea que
esteve na origem da teoria de linguagens formais foi a lgica, sendo aqui de destacar
o trabalho, na rea da computabilidade, de Alan Turing em meados da dcada de 30
do sculo XX. A lingustica tambm contribuiu para o desenvolvimento da teoria de
linguagens formais, em especial o trabalho de Noam Chomsky no estudo de gramticas,
tendo este autor apresentado uma hierarquia de linguagens formais baseada em tipos
de gramticas.
Da hierarquia de Chomsky [HU01] iremos lidar neste trabalho apenas com linguagens
regulares. O estudo de linguagens regulares e autmatos finitos data do incio da
dcada de 40 do sculo XX, em que autmatos finitos eram usados para modelar redes
neuronais por McCulloch e Pitts [MP43]. Resultados da investigao inicial so, por
exemplo, o teorema de Kleene que estabelece a equivalncia entre expresses regulares e
autmatos finitos [Kle56], a introduo de autmatos com output por Mealy e Moore
[M0066], a introduo de autmatos finitos no determinsticos por Rabin e Scott
[RS59] e a caracterizao de linguagens regulares por congruncias de ndice finito por
Myhill [Myh57] e Nerode [Ner58].
As linguagens regulares e os autmatos finitos tm uma grande variedade de aplicaes,

das quais se destacam a anlise lxica em compilao de linguagens de programao,
o desenho de circuitos, a edio de texto e a pesquisa de padres em texto. Em anos
1
mais recentes surgiram aplicaes nos domnios do processamento paralelo, gerao e
compresso de imagem, teoria de tipos para linguagens de programao orientadas a
objectos, computaes de ADN, etc [Yu97].
Neste trabalho, dentro do tema das linguagens regulares, iremos focar-nos no problema
de procurar, para uma dada linguagem deste tipo, uma sua representao por uma
expresso regular com o menor tamanho. O tema da simplificao de expresses
regulares foi abordado por alguns investigadores, nomeadamente os referidos em
[Mit03]. Estes trabalhos consistem em manipulaes algbricas de expresses regulares.
A nossa abordagem difere destas no sentido de que tentamos obter, a partir de um
autmato e baseados num algoritmo conhecido, uma expresso regular equivalente
com o menor tamanho. Nas nossas pesquisas, encontrmos muito pouco trabalho
neste sentido, sendo esta abordagem apenas referida em Regular Expressions: New
Results and Open Problems [ESW02], onde se diz, a propsito da converso de
autmatos finitos em expresses regulares, que "Dividir para conquistar, juntamente
com uma heurstica para a separao de grafos ou um algoritmo de aproximao sero
certamente tcnicas poderosas para a obteno de expresses regulares relativamente
pequenas a partir de autmatos arbitrrios..."; em A characterization of Thompson
digraphs [GPW99], onde se caracterizam os digrafos de Thompson (aqueles que so
obtidos a partir de uma expresso regular pelo algoritmo de Thompson) e para estes
se apresenta um algoritmo linear que produz uma expresso de tamanho linear no
tamanho do digrafo, em que o tamanho do digrafo o nmero das suas transies e
o tamanho de uma expresso regular o nmero total de ocorrncias na expresso de
smbolos de S U {e, 0}; e em Characterization of Glushkov automata [CZOO] onde algo
semelhante feito mas para autmatos de Glushkov.
Na seco seguinte apresentaremos as definies necessrias leitura deste trabalho.

No Captulo 2 apresentamos uma caracterizao de autmatos acclicos para os
quais pode ser encontrada de forma eficiente uma expresso regular que representa
a linguagem reconhecida pelo autmato e tendo tantos smbolos como o nmero
de transies do autmato. No Captulo 3 descrevemos uma heurstica que tenta
escolher, em cada passo do algoritmo da eliminao de estados, o estado cuja remoo
conduzir obteno de uma expresso regular pequena para um autmato arbitrrio.
Apresentamos tambm tabelas que comparam o tamanho das expresses obtidas
usando esta heurstica e as obtidas pelo algoritmo da eliminao de estados sem uma
2
escolha apropriada do estado a ser removido, pelas quais se verifica que a heurstica
produz melhores resultados. No Captulo 4 apresentamos uma heurstica com o mesmo
objectivo que a anterior, mas concebida especificamente para o caso de autmatos
acclicos e que, nestes casos, produz melhores resultados que a heurstica anterior.
No Captulo 5 delineamos a continuao deste trabalho que gostaramos de fazer no
futuro. Em apndice apresentamos o cdigo das vrias funes implementadas.
1.1 Definies Fundamentais
Apresentamos em seguida as definies fundamentais para a leitura deste trabalho.
Chamamos alfabeto a um conjunto finito e no vazio de smbolos. Uma palavra sobre

um alfabeto E uma sequncia finita de smbolos de E. Denotamos por e a palavra
vazia, i.e., a palavra que contm 0 smbolos.
A concatenao de duas palavras a palavra formada pela justaposio das duas,

i.e., a primeira imediatamente seguida pela segunda. Por exemplo, se considerarmos
o alfabeto E = {a, b} e as palavras x = aa e y = ab sobre E, a concatenao de x e y,
denotada por x y a palavra aa ab. Omitiremos, em geral, o smbolo quando nos
referirmos concatenao.
A potncia wn de uma palavra indutivamente definida por: w = e A wn+1 = wnw.
Denotamos por E* o conjunto de todas as palavras sobre o alfabeto E. O comprimento

de uma palavra x, que denotamos por \x\, o nmero de smbolos que constituem x.
Uma linguagem L sobre E um conjunto de palavras sobre E. A linguagem vazia

denotada por 0. A concatenao de duas linguagens L\ e L2 definida do seguinte
modo: L\-L2 = {w \ w = wiw2 A wi Li A w2 & L 2 )}.
Dada uma linguagem L definemse indutivamente as suas potncias por: L =

{e},!/ 1 = L e Ln+1 = Ln-L. O fecho de Kleene de uma linguagem L definido
do seguinte modo: L* [j V.
i>0
O conjunto das linguagens regulares sobre um alfabeto E definido como o menor

conjunto tal que:
3
a linguagem vazia 0 uma linguagem regular,
a linguagem {e}, constituda pela palavra vazia, uma linguagem regular,
para cada a S, a linguagem {a} uma linguagem regular,
se Li e L2 so linguagens regulares, ento Li U L2, Li L 2 e L\ so linguagens

regulares.
1.1.1 Expresses Regulares
Expresses regulares so uma forma sequencial de especificar uma linguagem regular

e foram originalmente introduzidas por Kleene [Kle56].
Definimos indutivamente uma expresso regular r sobre um alfabeto E e a linguagem

que ela representa L(r) do seguinte modo:
1. r = 0 uma expresso regular e denota a linguagem L(r) = 0.
2. r e uma expresso regular e denota a linguagem L(r) = {e}.
3. r a com a e E uma expresso regular e denota a linguagem L(r) = {a}.
Sejam T\ e r 2 duas expresses regulares, ento
4. r (ri + r 2 ) uma expresso regular e denota a linguagem L(r) = L ( r i ) u L ( r 2 ) .
5. r = (ri r 2 ) uma expresso regular e denota a linguagem L{r) = L(ri)L(r 2 ).
6. r = r* uma expresso regular e denota a linguagem L(r) = (L(ri))*.
Assumimos que * tem maior precedncia que e + e que tem maior precedncia que
+. Os parntesis sero omitidos sempre que isso no seja ambguo e omitiremos o
smbolo na escrita de expresses regulares.
Exemplo 1.1.1 A linguagem constituda por todas as palavras que comeam por aa
e terminam com sobre o alfabeto S = {a, b} pode ser representada pela expresso
regular aa(a + b)*bb.
4
1.1.1.1 Medidas de Complexidade de Expresses Regulares
Na literatura h vrias medidas de complexidade de uma expresso regular:
1. comprimento: o nmero total de smbolos, incluindo parntesis e operadores,

que ocorrem na expresso,
2. comprimento da expresso convertida para notao polaca (sem parntesis) e
3. o nmero total de ocorrncias de smbolos do alfabeto na expresso.
Uma expresso regular r diz-se colapsvel [ESW02] se e s se:
1. r contm o smbolo 0 e o nmero de smbolos em r for superior a 1 ou

2. r contm uma subexpresso da forma T\TI ou r^r-, em que L{r{) = {e} ou
3. r contm uma subexpresso da forma r\ + r? ou ri + ri, em que L(j\) = {e} e

e L(r2).
Todas estas medidas so equivalentes, a menos de um factor constante, se as

expresses forem no colapsveis [ESW02], pois podemos sempre acrescentar um
nmero arbitrrio de parntesis ou e a uma expresso regular sem modificar a
linguagem por ela descrita e desta forma deixaramos de ter uma relao definida
a menos de um factor constante entre as diferentes medidas. A terceira medida
apresentada tem a particularidade de estar relacionada com o nmero de estados de
um autmato obtido a partir de uma expresso regular: se o tamanho de uma dada
expresso regular r for n (segundo a medida 3), ento existe
um autmato finito no determinstico com no mximo n + 1 estados e que

reconhece a linguagem representada por r
um autmato finito determinstico com no mximo 2" +1 estados e que reconhece

a linguagem representada por r [ESW02].
Por outro lado, se L uma linguagem regular aceite por um autmato finito (ver pgina
8) A = (Q,T,,,q0,F) em que \ Q \= n e \ T, \= k, ento L pode ser representada
5
por uma expresso regular de tamanho (segundo a medida 3) no superior a nk4n
[ESW02].
Na nossa implementao das heursticas apresentadas neste trabalho, semelhana de

[TA98], definimos o tamanho de uma expresso regular r sobre , tamanho(r), como
sendo a soma do nmero de ocorrncias em r de smbolos do alfabeto e de ocorrncias
de e. No entanto, neste trabalho, consideraremos todas as expresses regulares na
sua forma no colapsvel. Optmos por esta medida pelo facto de, considerando
expresses no colapsveis, as ocorrncias de e no serem eliminveis (no sentido de
que so necessrias descrio da linguagem em causa) e como tal adquirirem um
significado que equivale ao de um smbolo do alfabeto.
1.1.1.2 Equivalncia de Expresses Regulares
Seja i? o conjunto das expresses regulares sobre o alfabeto E.
Duas expresses regulares res so equivalentes se representam a mesma linguagem

(L(r) = L(s)), denotando-se por r = s. Podem ser definidos vrios sistemas formais
para expresses regulares que so consistentes e completos a respeito da equivalncia
de expresses regulares [ST99] e que so a base da simplificao destas expresses em
abordagens algbricas. Apresentamos em seguida um desses sistemas [Koz94].
Considerando uma lgica de primeira ordem, um sistema dedutivo e os seguintes

axiomas:
1. r + (s + t) - (r + s) + t
2. r + s = s + r
3. r + $ = r
4. r + r = r
5. r(st) = (rs)t
6. er = r
7. re r
6
8. r(s + ) = rs + rt
9. (r + s)t = rt + st
10. 0r = 0
11. r0 = 0
12. e + rr* < r*
13. e + r*r < r*
14. s + ra; < x r*s < x
15. s + a;r < x > sr* < x
onde r < s = r + s = s,
temos que, se duas quaisquer expresses regulares res so equivalentes, ento r = s

um teorema do sistema (o sistema completo) e se r s um teorema do sistema,
ento r e s so equivalentes (o sistema consistente).
O problema de saber se duas expresses regulares so equivalentes PSPACE-completo

[GJ03].
1.1.2 Algumas Noes Elementares da Teoria de Grafos
Um grafo um par ordenado G (V, E), em que V um conjunto de vrtices e E

um conjunto de pares no ordenados (chamados arestas) de vrtices de V.
Um grafo dirigido, ou digrafo, um par ordenado G = (V, E), em que V um conjunto

de vrtices e E um conjunto de pares ordenados (chamados arcos) de vrtices de V.
Chamamos lacete a um arco da forma (u, u).
Neste trabalho, apenas consideraremos digrafos, pelo que, sempre que escrevermos
"grafo", estaremos a referir-nos a um digrafo.
Um caminho num grafo G uma sequncia de vrtices, Vi vn, tais que (V, Vi+\) G
E,l < i < n. C hamamos ciclo a um caminho em que o primeiro e o ltimo vrtices
so o mesmo.
7
Definimos o grau de entrada de um vrtice v, num grafo G, ge(v), como o nmero de
arcos (u, v) de G, com u^v. Analogamente, definimos o grau de sada de um vrtice
v, num grafo G, gs(v), como o nmero de arcos (v, u) de G, com u ^ v [BJG01]. Uma
ordem topolgica T num grafo acclico G (V, E) com | V | = n uma funo de V
em { 1 , . . . , n} tal que se (u, v) & E ento T(u) < T(v).
usual representar um grafo G = (V, E) de uma das seguintes formas:
lista de adjacncias: uma lista em que o i-simo elemento a lista dos vrtices
v tais que (i, v) G E e
matriz de adjacncias: uma matriz Anxn com n = \V\, tal que A^ 1 se

(z, j) E e A[i,j] = 0 caso contrrio.
1.1.3 Autmatos Finitos
Nesta subseco iremos apresentar quatro tipos de autmatos finitos (AF): autmatos
finitos determinsticos (AFD), autmatos finitos no determinsticos (AFND),
autmatos finitos no determinsticos com transies-e (AFNDTE) e autmatos finitos
estendidos (AFE).
1.1.3.1 Autmatos Finitos Determinsticos
Um autmato finito consiste num nmero finito de estados e um conjunto de regras

que definem a mudana de estado quando o autmato l um smbolo do seu input. Se
o estado seguinte for unicamente determinado pelo estado actual e pelo smbolo lido,
dizemos que o autmato determinstico.
Formalmente, definimos um AFD A como sendo um quntuplo (Q, S, , 0 , F) onde
Q o conjunto finito de estados,
S o alfabeto de input,
5 : Q x S - > Q a funo de transio,
9o Q o estado inicial e
8
F Q o conjunto de estados finais.
Note-se que em geral no requeremos que a funo de transio S seja total, i.e., que
esteja definida para todos os pares e m Q x E . Se 6 for total dizemos que A um AFD
completo.
Exemplo 1.1.2 Seja A = (Q,E,6, 0, F) um AFD onde Q = {1,2,3}, E = {a, 6},

o = 1, F = {2,3} e 6 definida do seguinte modo:
(l,o) = l, S(l,b) = 2,
(2,a) = l, (2,6) = 3,
6(3,0.) = 2, 6(3, b) = 3.
Na Figura que se segue encontra-se uma representao grfica deste autmato, em que
existe o arco (1,1*2) etiquetado por a se 6(vi,a) = V2, o estado inicial indicado por
uma seta com a cabea nesse estado e a cauda em nenhum estado e os estados finais
so representados com crculos duplos.
Uma configurao de A = (Q, E, 6, q0, F) uma palavra de QT,*, i.e., um estado q Q

seguido de uma palavra S * , onde q o estado actual do autmato e i a parte
do input que falta ser lida. A configurao inicial de A com input x ET,* qox. Uma
configurao de aceitao definida por fe com / F.
Um passo de computao de A uma transio de uma configurao a para uma

configurao /3, denotando-se por a h^ 0 e uma relao binria no conjunto de
configuraes de A. A relao h^ definida por: para px,qy G QT,*,px \~A qy se
x = ay para algum a E e <5(p, a) = . Usaremos a notao a h /?, em vez de a h^ /?,
se no houver lugar para dvidas quanto ao autmato em causa.
A potncia k de h, denotada por h*, definida indutivamente por 1 - % para todas

as configuraes a G QE* e a r - * / ? , para A; > 0 e a, /? G QE*, se existe 7 G QH*
9
tal que a h * - 1 7 e 7 h j3. O fecho transitivo e o fecho reflexivo e transitivo de h so
denotados por h + e h* respectivamente. Uma palavra i E ' aceite por um AFD
A se e s se q0x \-*A fe com / G F. A linguagem aceite por um AFD A o conjunto
das palavras aceites por A e designa-se por L(4).
1.1.3.2 Autmatos Finitos no Determinsticos
Os autmatos finitos no determinsticos so uma generalizao do caso determinstico

em que, para um dado estado e um smbolo de input, o nmero de transies possveis
pode ser superior a um.
Formalmente, um AFND A um quntuplo (Q, E,5, q0, F) onde Q, S, 0 e F so

definidos exactamente como no caso determinstico e i : Q x E -> 2 e a funo
de transio, onde 2 representa o conjunto dos subconjuntos de Q.
Exemplo 1.1.3 Seja um AFND A = (Q,~Z,,q0,F) onde Q = {1,2,3}, E = {a,b},

q0 = 1, F = {2,3} e definida do seguinte modo:
<5(1, a) = {1,2}, 5(1,6) = {2,3},

<5(2,a) = 0, (2,) = 0,
(3,a) = 0, 5(3,6) = {3,2}.
Na Figura seguinte encontra-se uma representao grfica deste autmato.
Um passo de computao de um AFND A uma relao binria definida em QS*,

h.4: QH* x QT,* tal que px h ^ qy se x = ay e q (p, a) com p, q Q, x, y e S* e
a S. O fecho transitivo e o fecho reflexivo e transitivo de h so denotados por h + e
(-* respectivamente. Uma palavra x G S* aceite por um AFND se e s se q0x h* / e
10
com f F. A linguagem aceite por um A FND o conjunto das palavras aceites pelo
autmato em causa.
1.1.3.3 Aut mat os Finit os no Det erminst icos com Transies-e
Um autmato finito no determinstico com transiese (AFNDTE) A um quntuplo

(Q, E, , i/o, F) em que Q, E, q0 e F so como no caso de um A FND e a funo de
transio : Q x (E U {e}) > 2Q.
Um passo de computao de um AFNDTE A uma relao binria definida em QE*,

\~X- QE* x QE* tal que px K4 qy se x = ay e q G (p, a) ou se x = y e q 6{p, e) com
p,q E Q,x,y e "E* e a <E T,. Uma palavra x E E* aceite por um A FND se e s se
qox h* fe com / F. A linguagem aceite por um AFNDTE o conjunto das palavras
aceites pelo autmato em causa.
1.1.3.4 Aut mat os Finit os Est endidos
Um autmato finito estendido semelhante a um A FNDTE com a diferena de que

as etiquetas das transies podem ser, no apenas smbolos do alfabeto ou e, mas
expresses regulares gerais.
Seja i?s o conjunto das expresses regulares sobre o alfabeto E. Formalmente, um

AFE A um quntuplo (Q, E, 6, qo, F) onde
Q o conjunto finito de estados,
E o alfabeto de input,
6 : Q x Q > i? s a funo que descreve as transies do autmato,
qo o estado inicial e
F Q o conjunto de estados finais.
Assumimos que (p, q) == 0 se a transio de p para q no est presente.
Uma palavra x E* aceite por A se x x\ , x n com x\,...,xn E* e existe

uma sequncia de estados qo,qi,...,qn com qn G F tal que x\ G L((qo, i)),..., G
11
L(5(qn-i,qn)). A linguagem aceite por um A FE o conjunto das palavras aceites pelo
autmato em causa.
Seja A = (Q, E, 6, q0, F) um A FE. Definimos a funo + : Q x Q > i2 E tal que,

para cada caminho Cj = u\ un temos (u,Ui) = ri,...,S(un-i,un) = re
+
r^ = r x .. .r, sendo 5 (i, un) = rCl H h r ^ em que e i , . . . , cm so os caminhos de
Mi para un. No captulo seguinte usaremos esta funo, escrevendo S+(p, q) = 0 para
indicar que existe um caminho de p para q.
Assumimos tambm que num A FE no h duas transies de um estado p para um

estado q pois fcil concluir que a linguagem aceite pelo A FE em causa no se
altera se substituirmos estas duas transies por uma nica, etiquetada pela unio das
expresses que etiquetavam as transies iniciais. Um caminho de um vrtice vx para
um vrtice vn no grafo subjacente a um autmato finito estendido A = (Q, S, , q0, F)
fica assim unicamente definido pela sequncia V\ vn de vrtices tais que
(vi,vi+1) 7^0,1 < i < n.
1.1 A A utmatos e Grafos
O grafo subjacente a um A F A = (Q, S, <5, q0, F) o grafo G = {Q,E), em que

E = {(u, v) | u,v Q e 3a E tal que (u, a) = v no caso de AFNDs ou (u, v) =
a no caso de AFEs}.
No grafo subjacente a um autmato finito, chamaremos vrtices iniciais aos vrtices

correspondentes aos estados iniciais do autmato, vrtices finais aos vrtices corre
spondentes aos estados finais e vrtices intermdios a todos os outros.
Chamamos autmato til a um autmato em cujo grafo subjacente passa por todo o
vrtice algum caminho entre o vrtice inicial e um vrtice final e para cada vrtice
final fin existe um caminho do vrtice inicial para fin. Dizemos que um autmato
acclico se no contm nenhum ciclo.
Dada a sua ntima relao, usaremos a terminologia para autmatos e grafos

indistintamente.
12
1.1.5 Equivalncia dos Modelos Apresentados
Dois AFs A e A' dizem-se equivalentes se L(A) = L(A'). Os AFDs so casos

particulares de AFNDs e possvel transformar um AFND ou um AFNDTE num
AFD equivalente (ver [ASU86]).
Um AF aceita um conjunto de palavras (no sentido de que dada uma palavra w e

um autmato A possvel saber se w L(A)), ao passo que uma expresso regular
representa um conjunto de palavras (no sentido de que a expresso regular um
padro ao qual obedecem todas as palavras pertencentes linguagem representada
pela expresso).
As expresses regulares e os AFs tm o mesmo poder descritivo, ou seja, dada uma

expresso regular r possvel construir um AF A tal que L(r) = L(A) e vice-versa. Um
dos algoritmos mais comuns para converter uma expresso regular num AF equivalente
o algoritmo de Thompson [Tho68]. Este algoritmo produz um AFNDTE com
tamanho linear no tamanho da expresso regular e f-lo em tempo linear [GPW98].
Uma das caractersticas destes autmatos (cuja caracterizao se pode encontrar em
[GPW99]) o facto de terem apenas um estado final. Uma taxonomia dos mtodos de
converso de uma expresso regular num autmato equivalente pode ser encontrada em
[Wat94b]. Esta converso encontra-se extensivamente estudada na literatura devido
s suas mltiplas aplicaes, embora o mesmo no acontea com a converso inversa.
Assim tambm vemos que um AFE pode ser transformado num AFNDTE equivalente,
substituindo o arco entre dois estados p e q pelo AFNDTE que resulta da aplicao
do algoritmo de Thompson expresso 6(p, q), uma vez que o autmato de Thompson
resultante tem apenas um estado final. Claramente, um AFNDTE pode ser visto como
um AFE, resultando a equivalncia entre AFEs e AFNDTEs.
A converso de um AFND (ou AFNDTE) numa expresso regular equivalente pode

ser feita usando o algoritmo da eliminao de estados, descrito na Seco 1.1.7. Alm
deste algoritmo, existe outro, que o algoritmo apresentado por Kleene [Kle56] para
converter AFNDs em expresses regulares e descrito na Seco 1.1.8.
Este segundo algoritmo produz, regia geral, expresses de tamanho superior s

produzidas pelo algoritmo da eliminao de estados.
13
1.1.6 Autmatos Mnimos
Dado um AFD A possvel encontrar um AFD A' tal que L(A) L(A') e A' mnimo
no nmero de estados. Um dos algoritmos para a minimizao encontra-se descrito em
[ASU86] e uma taxonomia destes algoritmos pode ser encontrada em [Wat94a]. O AFD
mnimo para uma dada linguagem regular nico a menos de uma renomeao dos
estados [ASU86], o que permite testar se dois autmatos aceitam a mesma linguagem.
Um AFND mnimo no nmero de estados pode no ser nico no conjunto dos AFNDs
que lhe so equivalentes, o mesmo acontecendo com as expresses regulares. Em termos
de espao, a representao de uma linguagem regular por um AFND pode oferecer uma
vantagem exponencial em relao a um AFD [HK02]. 0 problema de converter um
AFD num AFND equivalente e minimal PSPACE-completo [JR93]. O problema da
minimizao de AFNDs PSPACE-completo (excepto no caso de alfabetos unrios,
em que o problema NP-completo) [GJ03].
1.1.7 Algoritmo da Eliminao de Estados
O algoritmo da eliminao de estados (AEE) permite obter uma expresso regular que
representa a linguagem reconhecida por um dado AF. O AEE consiste em remover em
cada passo um vrtice do AFE associado ao autmato finito dado e na actualizao
do AFE resultante de forma a que a linguagem reconhecida no se altere. O algoritmo
termina quando restarem apenas dois vrtices ira e fin (que no so removveis e que
so, respectivamente, um novo estado inicial do qual parte uma transio por e para
o estado inicial, que deixa de ser inicial e um novo estado final para o qual h uma
transio por e de cada estado final, deixando estes de ser finais) e a expresso regular
de output S(ini,fin).
Seja A (Q,T,,,q0,F) um AFE e rPq a expresso regular (p, q), i.e., a etiqueta da
transio entre p e q, p, q Q. Seja q um estado tal que q ^ q0 e q F. Um AFE
A' = (Q1, S, 6', o, F) equivalente a A tal que Q' = Q {<?}, i.e., em que q foi removido
de A, definido do seguinte modo: para cada par de estados pes pertencentes a Q',
'(p, s) = rps + rpqr*qqrqs. (1.1)
14
A descrio completa do algoritmo a seguinte (ver [Yu97]): Seja A (Q, S, S, q0, F)
um AFE,
1. Se o estado inicial for tambm final ou se tiver grau de entrada superior a 0, ento
adiciona-se a A um novo estado ini no removvel e inicial e uma transio por
e de ini para o estado inicial e este deixa de ser inicial; se o estado inicial no
for final e tiver grau de entrada 0, ento no necessrio acrescentar um novo
estado e toma-se o estado no removvel, ini, como sendo o estado inicial. Se
houver mais que um estado final ou se o nico estado final tiver grau de sada
superior a 0, ento acrescenta-se um novo estado ao autmato, fin no removvel
e final e uma transio por e de cada estado final para fin, deixando estes de
ser finais; se houver apenas um estado final e este tiver grau de sada 0, ento
no necessrio acrescentar um novo estado e toma-se o estado no removvel,
fin, como sendo o estado final.
Seja A' = (Q1, E, S', ini, fin) o autmato assim obtido.
2. Se Q' consiste apenas em ini e fin, ento a expresso regular resultado

6'(ini, fin) e o algoritmo termina. Caso contrrio executa-se o passo seguinte.
3. Escolhe-se q G Q' tal que ini / q / fin, remove-se q de A' como indicado acima,
actualizando ' como na Equao (1.1) e executa-se o passo 2.
1.1.7.1 Implementao
O GAP um sistema de software livre sob GPL (GNU Public License) para lgebra
computacional discreta e o seu nome um acrnimo de Groups, Algorithms and
Programming. Este sistema fornece uma linguagem de programao imperativa.
Na Seco A.l (pgina 93) apresentamos uma implementao do AEE escrita em
GAP [GAP04]. Esta implementao fez, inicialmente, parte de um pacote sobre
autmatos [DLM04] desenvolvido em colaborao com M. Delgado (Universidade
do Porto) e S. Linton (Universidade de St. Andrews) e aceite para integrar
futuras distribuies do GAP. Esta implementao foi posteriormente substituda pela
heurstica descrita no Captulo 3.
Neste pacote, as transies de um AFND A (Q,T,,6,q0,F) so representadas por

uma matriz E x Q e m que cada entrada [a,],a S, q Q a lista dos estados s
15
tais que do estado q h uma transio para s etiquetada por a. No cdigo chamamos
GTG - Generalized Transition Graph [MMP + 95] ao AFE associado ao autmato de
input. A funo computeGTG calcula o AFE associado ao AF dado e as funes
destroyLoop e d e s t r o y S t a t e implementam, respectivamente, a eliminao de um
estado pela eliminao primeiro do lacete, se existir e em seguida a eliminao do estado
propriamente dita. A funo RatExpOnnLetters(n, op, l i s t ) cria uma expresso
regular sobre um alfabeto S de n smbolos, em que op [ ] , product, union ou s t a r
conforme se trate de um smbolo do alfabeto (ou e ou 0), ou uma concatenao, ou
uma unio ou o fecho de Kleene, respectivamente; l i s t uma lista de expresses
regulares (as subexpresses) se se trata de uma concatenao ou unio, [n] se se trata
do n-simo smbolo de no caso de a expresso ser um smbolo de E (considera-se
uma ordem em E) ou uma expresso regular se se trata do fecho de Kleene.
Na Figura 1.1 apresentamos o corpo "principal" desta implementao.
FAtoRatExpX := function(A)
# . . . Definies das funes locais . . .

# Q o nmero de estados do AFE
computeGTGO; # Converte o autmato i n i c i a l
# no AFE equivalente
while Q > 0 do
destroyLoop(Q); # Elimina lacete do estado Q
destroyState(Q); # Elimina o estado Q
od;
# Devolve a expresso resultado
# T[p][q] a etiqueta do arco (p,q)
if T[l] [2] = 0 then
return(RatExpOnnLetters(A!.alphabet, [ ] , "empty_set"));
else
return(T[l][2]);
fi;
end;
Figura 1.1: Algoritmo da Eliminao de Estados
16
A funo computeGTG executada uma nica vez e tem complexidade 0(kn3) no caso
2
de o input ser um AFND ou um AFNDTE e 0{kn ) no caso de um AFD, em que n
o nmero de estados do AF de input e k = | S |. Como se pode ver pelas seguintes
linhas de cdigo da funo computeGTG a complexidade Q(kn3):
f o r p i n [1 . . A ! . s t a t e s ] do
for q in [1 . . A ! . s t a t e s ] do
for a i n [1 . . A!.alphabet] do
i f q in A ! . t r a n s i t i o n s [ a ] [ p ] then
fi;
od;
od;
od;
em que A! . s t a t e s o nmero de estados do autmato inicial, A! . a l p h a b e t = A; e

A! . t r a n s i t i o n s [ a ] [p] a lista de estados para os quais h uma transio do estado
p pelo smbolo do alfabeto a. No caso de um AFD esta lista encontra-se reduzida a
um nico estado, pelo que a complexidade neste caso 0(kn2).
A funo destroyLoop executada n vezes e tem complexidade 0{knAn). Esta

complexidade est interligada com a complexidade da funo d e s t r o y S t a t e (estas
duas funes implementam a remoo de um estado em dois passos, removendo
primeiro o lacete e depois o estado) e deve-se ao facto de em cada chamada destas
funes o tamanho das expresses regulares envolvidas quadriplicar e ter um tamanho
mximo inicial de k (no autmato inicial pode haver no mximo k transies entre
quaisquer dois estados, sendo, no AFE inicial, reduzidas a uma nica transio
etiquetada por uma expresso de tamanho k). A funo d e s t r o y S t a t e executada n
vezes e tem complexidade 0{n2kAn). Esta complexidade deve-se s razes indicadas
atrs e ao facto de a actualizao das etiquetas das transies ser feita dentro do ciclo
for p i n [1 . . n-1] do
17
for q in [1 . . n-1] do
. . . Actualizao das etiquetas das t r a n s i e s . . .
od;
od;
em que n o estado a ser removido. Por tudo isto o algoritmo tem complexidade
0(n3Mn).
1.1.8 Algoritmo de Kleene
Em seguida descrevemos o algoritmo de Kleene para converter um AFND numa

expresso regular equivalente [Aho04]:
Input: AFND A (Q,T,,,qQ,F), em que Q = {1,2, . . . , n } . Representamos por
L[i,j] a etiqueta do arco (i, j) (se este arco no existir, temos L[i, j] = 0; se existir
mais que um arco, ento L[i,j] a expresso que representa a unio das etiquetas
destes arcos) e por @ representamos e.
Output: Matriz Cnxn em que CJ uma expresso regular que descreve todos os
caminhos de i para j e constri-se calculando sucessivos C_k [ i , j ] , em que C_k [ i , j ]
uma expresso regular que descreve todos os caminhos de i para j que no passam por
nenhum vrtice cuja numerao seja superior a k (com a possvel excepo do primeiro
e ltimo vrtices desses caminhos). A expresso resultado ser ( J Cq0tq. A descrio
apresentada na Figura 1.2 conceptual e no corresponde a uma implementao numa

linguagem de programao concreta.
1.2 Descrio do Problema
O problema que abordamos neste trabalho o de, dado um autmato finito, encontrar,
pelo algoritmo da eliminao de estados, uma expresso regular equivalente com o
menor tamanho. Quando aplicamos a um autmato o algoritmo da eliminao de
estados, a ordem de remoo dos vrtices influencia o tamanho da expresso regular
obtida. Assim, a obteno de uma expresso de menor tamanho pode ser feita atravs
de uma escolha adequada da ordem de remoo dos vrtices.
18
procedure Kleene(A){
for i := 1 to n do
for j := 1 to n do
C_0[i,j] := L[i,j];
od;
od;
for i := 1 to n do
C_0[i,i] := 0 + C.OCi.i];
od;
for k := 1 to n do
for i := 1 t o n do
for j := 1 t o n do
C_k[i,j] := C_{k-l}[i,j] +
C_{k-i}[i,k].(C_{k-l}[k,k])*.C_{k-l}[k,j]
od;
od;
od;
for i := 1 t o n do
for j := 1 to n do
C [ i , j ] := C _ n [ i , j ] ;
od;
od;
return(C);
Figura 1.2: Algoritmo de Kleene
19
Consideremos o autmato da Figura 1.3.
VL)"~QD
Figura 1.3: Autmato A
Se neste autmato removermos os vrtices na ordem 2,1,4,3, (ver Figuras 1.4 a 1.7
em que I ini e F fin), obtemos a expresso regular r = a+ (b+aa)(ba + a(b+a(b+
aa)))*(b+aaa) em que tamanho(r) = 16; se, por outro lado, removermos os vrtices na
ordem 3,4,2,1 (ver Figuras 1.8 a 1.11), obtemos a expresso regular s = (ba(ba)*a +
(a + bb + ba(baybb)(ab + aa(ba)*bb)*aa(ba)*ay(a + bb + ba(baybb)(ab + aa(ba)*bby em
que tamanho(s) = 44.
Figura 1.4: Autmato A depois de removido o vrtice 2
Figura 1.5: Autmato A depois de removidos os vrtices 2 e 1
20
b + aa
& ba + a(b + a{b + aa))
Figura 1.6: Autmato A depois de removidos os vrtices 2, 1 e 4

a + (b + aa){ba + a(b-\-a(b + aa)))"(b + aaa)

Figura 1.7: Autmato A depois de removidos os vrtices 2, 1, 4 e 3
ba(ba)*a
aa(ba)*a
2 t 3 a ' ) + aa(ba)"bb
21
ba(ba)*a + (a + bb + ba(ba)''bb)(ab + aa(ba)*bbyaa(ba)'a
(a + bb + ba(ba)'bb) (ab + aa(ba)*bb)*
0
(ba(ba)'a + (a + bb + ba(ba)'bb){ab + aa(6a)*h6)*aa(6a)*a)*(a + bb + ba(ba)*bb)(ab + aa(6a)*66)*

No caso geral, encontrar uma ordem ptima (no sentido de ser uma que produz
uma das expresses de menor tamanho) de remoo dos vrtices um problema
computacionalmente difcil. O algoritmo por "fora bruta", que consiste em aplicar o
AEE em todas as ordens de remoo possveis, tem complexidade 0(n\), uma vez que
para um autmato de n estados h n! ordens de remoo diferentes.
Como veremos no Captulo 5, o AEE, mesmo quando aplicado ao AFD mnimo de

uma dada linguagem, pode no produzir uma expresso mnima para essa linguagem.
22
Captulo 2
Autmatos nard
Neste captulo apresentamos uma caracterizao de autmatos acclicos para os quais

a ordem ptima de remoo dos vrtices pode ser encontrada de forma eficiente.
Neste captulo e nos seguintes consideraremos apenas autmatos teis, uma vez que
as etiquetas dos arcos (u, v) em que u ou v so vrtices no teis (vrtices que no
fazem parte de nenhum caminho do vrtice inicial para um vrtice final) no estaro
presentes como subexpresses do resultado, no contribuindo assim para o aumento
do tamanho da expresso regular final.
Neste captulo consideraremos apenas autmatos com um nico estado final, uma vez
que o caso de autmatos com mais do que um estado final pode ser reduzido ao caso
de um nico estado final, pela introduo de uma transio por e de cada estado final
(deixando estes de ser finais) para um novo estado, sendo este o nico estado final.
Para os autmatos considerados neste captulo verifica-se que o tamanho da expresso

regular obtida pelo AEE modificado para este caso igual ao nmero de transies do
autmato inicial.
2.1 Introduo
Neste captulo tratamos de autmatos a que demos o nome de nard, que um

acrnimo de no ambguo (relativamente s) regras da distributividade, sendo as
regras da distributividade as regras nmeros 8 e 9 do sistema formal apresentado
23
na Seco 1.1.1.2 (ver pgina 6).
Figura 2.1: Grafo Etiquetado
Considerando o grafo da Figura 2.1 (que no nard como veremos), se removermos

primeiro, numa aplicao do AEE, o vrtice u2 e em seguida o vrtice U3 obtemos a
expresso regular ad+ (ac + b)e. Se, em alternativa, removermos primeiro o vrtice u3
e em seguida u 2 , obtemos a expresso be + a(ce + d). Podemos notar que no primeiro
caso o smbolo a o nico que ocorre duas vezes na expresso, ao passo que no segundo
caso o smbolo e, ou seja, no primeiro caso aplicmos a regra da distributividade
direita a e e no segundo, esquerda, a a. No caso geral isto causa a ambiguidade de
sabermos se devemos remover primeiro um ou outro vrtice, uma vez que, no sentido
de obter uma expresso de menor tamanho, devemos remover aquele vrtice que causa
a aplicao da regra da distributividade etiqueta de maior tamanho, o que nem
sempre trivial de determinar.
No caso da aplicao do AEE a um autmato nard este problema no se pe, uma vez
que, como veremos, ser sempre removido um vrtice v tal que ge(v) = 1 = gs(v), no
havendo portanto ocorrncias mltiplas na expresso final da etiqueta de uma dada
transio.
2.2 Autmatos nard
Comeamos por introduzir algumas definies e usamos a funo definida na

Seco 1.1.3.4, escrevendo +(p, q) 7^ 0 para indicar que existe um caminho de p
para q.
Definio 2.2.1 (Forma nard) Dizemos que um autmato acclico til, com apenas
um estado inicial (que denotaremos sempre por nj e um estado final (que denotaremos
24
sempre por fin^ se encontra na forma nard se no seu grafo subjacente no existirem
vrtices intermdios V\ e v2 (v\ ^ v 2 j tais que:
1. existe um caminho de ini para vi que no passa por\2 e um caminho de ini para
v2 que no passa por vi e
2. existe um caminho de Vi para fin que no passa por v2 e um caminho de v2 para

fin que no passa por vi e
5. exse um caminho de vi para v2 e
4- no existe nenhum vrtice intermdio u tal que: existem os caminhos v\ u

eu 2 e todos os caminhos de ini para v% passam por u.
Na Figura 2.2 temos um autmato que no se encontra na forma nard porque se

considerarmos V\ o vrtice 2 e v2 o vrtice 3, ento 1 2 um caminho de ini para v\
que no passa por i;2, 1 3 um caminho de ini para i>2 que no passa por vi, 2 4
um caminho de Vi para fin que no passa por v2, 3 4 um caminho de w2 para
fin que no passa por vi e 2 3 um caminho de v\ para w2 e no existe nenhum
vrtice intermdio u tal que existem os caminhos V\ ueu u 2 e todos os
caminhos de ini para v% passam por u.
Figura 2.2: Autmato no nard
Na Figura 2.3 temos um exemplo de um autmato em forma nard.
XD
Figura 2.3: Autmato nard
25
Definio 2.2.2 (Homeomorflsmo de Grafos) Dois grafos so homeomorfos se
existir um terceiro a partir do qual ambos podem ser obtidos por uma sequncia de
operaes em que um arco (u,v) subdividido nos dois arcos (u,q) e (q,v), sendo q
um novo vrtice [Har69j.
Definio 2.2.3 (Grafo D) Definimos o grafo D como sendo D =

({!, U2, U3, U 4 }, {(1, U2), (1, U3), (u2, U3), (U2, lt 4 ), (M 3 , l 4 )}).
Figura 2.4: Grafo D
Proposio 2.2.1 Um autmato acclico til, com apenas um estado final nard se
e s se o seu grafo subjacente no contiver como subgrafo um grafo homeomorfo a D.
Demonstrao: Seja G o grafo subjacente a um autmato acclico til, com apenas

um estado final. Suponhamos que G contm como subgrafo um grafo homeomorfo a
D. Claramente em G existem os vrtices V\ e v2 da Definio 2.2.1, que satisfazem as
condies 1 a 3 da mesma definio, nomeadamente, os vrtices vi e v2 da Definio
2.2.1 seriam respectivamente os vrtices u2 e u 3 da Definio 2.2.3. Se em G existir um
ou mais vrtices u nas condies da condio 4 da Definio 2.2.1, ento, tomando v2
como sendo o vrtice u de menor valor numa ordem topolgica em G, temos satisfeita
a Definio 2.2.1. Provmos assim que se um autmato se encontra em forma nard,
ento ele no contm como subgrafo um grafo homeomorfo a D.
Vamos agora provar que se G contm como subgrafo um grafo homeomorfo a D ento
no se encontra em forma nard. Suponhamos que em G existem vrtices V\ e v2 nas
condies da Definio 2.2.1. Tomemos o subgrafo de G definido por ini e vrtices e
arcos no caminho ini vi que no passa por v2, ini e vrtices e arcos no caminho
ini v2 que no passa por v\, V\ e vrtices e arcos no caminho V\ v2, V\ e
vrtices e arcos no caminho V\ fin que no passa por v2 e v2 e vrtices e arcos
no caminho v2 fin que no passa por v\. Podemos concluir que este subgrafo
homeomorfo a D, nomeadamente, identificando, respectivamente, ini, V\, v2 e fin com
26
1,^2, 3 e 4 da Definio 2.2.3. Estando provadas as implicaes nos dois sentidos
segue a veracidade da proposio.
Foi feita uma contagem dos grafos nard de entre os grafos de at 7 vrtices, acclicos,
com apenas um vrtice u tal que ge(u) = 0 e um vrtice v tal que gs(v) = 0 e teis
no sentido de que todos os vrtices fazem parte de algum caminho de u para v e os
resultados so apresentados na Tabela 2.1.
Tabela 2.1: Contagem de Grafos Nard
Vrtices Total No nards Nards Percentagem de nards

1 1 0 1 100%
2 1 0 1 100%
3 2 0 2 100%
4 8 2 6 75%
5 64 42 22 34,4%
6 1024 942 82 8%
7 32768 32470 298 0,9%
Vamos mostrar que se um autmato nard ento contm um estado v tal que ge(v) =
1 = gs(v). Seja A = (Q,T,,6,ini, {fin}) um autmato nard tal que gs(ini) > 1
e ge(fin) > 1. Sejam i , . . . , u m os vrtices tais que (ini,Ui) 7^ 0,1 < i < m e
U = {i,.. .,um}. Seja XUi = {IJ U{x \ x e Q\ {fin} A +(uhx) ^ 0}. Seja
R uma relao binria em U x U tal que para ui,U2 U se tem u\Ru2 se e s se
xui n xU2 0.
Proposio 2.2.2 A relao R uma relao de equivalncia.
Demonstrao: A reflexividade e simetria de R so triviais. Sejam ui,U2,3 U

e tais que u\Ru2 e U2R.U3. Ento, pela definio de R, existe x Q\ {fin} tal que
J+(i,ar) 7^ 0 e S+(u2,x) ^ 0 (ou x = u\ ou x = 2) e existe y E Q\ {fin} tal que
+ (u 2 , y) # 0 e <5+(u3, y) / 0 (ou y = u2 ou y = tt3). Tomemos estes x ey como os dois
vrtices com menor valor numa ordem topolgica T em A de entre os que obedecem
27
s mesmas condies. Vamos mostrar que tem de se ter +(x,y) / 0 ou 5+(y,x) ^ 0,
ou x = y, provando assim que XUl D XUA ^ 0, ou seja, UiRu3.
Se x = y ou x = u2 = y fcil concluir que XUl D XU3 ^ 0, nomeadamente, x G

XUl n XU3. Sex u2ex^ye por y G XU2 fi XU3 temos que + (, y) ^ 0, ou seja
y G XU1 nX U3 . Suponhamos, nos outros casos (x ^ u 2 ), que S+(x, y) = 0 e i + (y, a;) = 0
ex^y. Nestas condies, existe um caminho ini x (o que passa por ui) que no
passa por u2 por termos i ^ 2 e o valor de a; em T ser mnimo. O caminho ini u2
no passa por x. De existe um caminho para fin que no passa por u2 por termos
S+(u2,x) ^ 0 e A ser acclico. Por u2Rus temos um caminho M2 y fin que
+ +
no passa por x por termos & (x, y) = 0 e (y,x) = 0. Tomando respectivamente u2
e x como os vrtices V\ e v2 da Definio 2.2.1, temos que, no existe nenhum vrtice
u nas condies do ponto 4 da Definio 2.2.1, pois se existisse, todos os caminhos de
Ui e u2 para x teriam de passar por u e assim teramos u G XUl n XU2 e u com menor
valor em T do que x, o que uma contradio. Assim u2 e x seriam os vrtices Vi e
v2 da Definio 2.2.1, o que contradiz o facto de o autmato ser nard. D
Proposio 2.2.3 Seja, num autmato nard A, tal que gs(ini) > 1 e ge(fin) > 1,
uma classe de equivalncia [ui] de R com mais que um elemento, ento, | j Xu / 0
e[i]
Demonstrao: Se | [u\] |= 2, temos XUIDXU2 ^ 0, com u\, u2 G [1], pela definio

de i?. Suponhamos que a proposio verdadeira para todas as classes de equivalncia
[ui] tais que | [ui] \< n. Seja [ui] com n elementos. Tomemos n l elementos de [ui],
U\,... ,u n _! e o subgrafo A' de A definido pelos vrtices emXUlU- UXUn_1U{mi, fin}
e arcos com ambas as extremidades neste conjunto. A' tem apenas um estado inicial
(ini) e um estado final (fin), acclico, por ser subgrafo de um grafo acclico e por
isto e por ser subgrafo de um grafo nard, tambm nard. Neste subgrafo, U\,..., un-\
constituem a nica classe de equivalncia ([tti]') de R e esta classe tem n l elementos,
pelo que, por hiptese de induo, Pj Xu^$. Por se tratar de um subgrafo de A
ue[ui]'
temos que, em A, X = XU1 n D XUn_l ^ 0. Por un G [1] e pela definio de
R temos XUn n XUi ^ 0,1 < i < n - 1. Seja v' G XUn n XUl e v G X. Em
particular, v G XUl D XU2 e na prova da transitividade de R mostrmos que temos de
ter +(v,v') ^ 0 ou +(v',v) 0. Se for 6+(v,v') j 0, temos que v' G f] Xu (pela
transitividade de +) e se for S+(v', v) ^ 0 temos que [ ] Xu (pela transitividade

u[ui]
28
de +), pelo que f] Xu # 0. D
Proposio 2.2.4 .Seja, num autmato nard A, tal que gs(ini) > 1 e ge(fin) > 1,
uma c/a&se de equivalncia [ui] de R com mais que um elemento e q (^ X a o
U6[MI]
estado com menor valor numa ordem topolgica T em A, de entre os que obedecem
s mesmas condies. Seja Zq = {z \ z e [j Xu e +(z,q) ^ 0}. Ento, para todo
ue[ui]
z <E Zq, se c = z s\ sn fin um caminho de z para fin, ento existe
1 < i < n tal que Si = q, ou seja, todos os caminhos z fin passam por q.
Demonstrao: O caminho c = z si sn fin, se para 1 < i < n,Si ^ q,

seria o caminho de v\ para fin sem passar por v2 da Definio 2.2.1 (tomando z como
i e q como v2). Este caminho a nica condio da Definio 2.2.1 que falta satisfazer
para que A seja no nard, porque existe caminho de ini para z que no passa por q,
pela definio de Zq e por A ser acclico [z antecessor de q). Se todos os caminhos
de ini para q passassem por z teramos z E f] Xu e o valor de z em T seria menor
u[ui]
que o de a, o que uma contradio, pelo que, existe um caminho de ini para q que
no passa por z. Por A ser acclico e por z Zq (z antecessor de q) temos que, no
existe nenhum caminho de q para z, e por A ser til, existe um caminho de q para fin
que no passa por z. Se existisse um vrtice v nas condies do ponto 4 da Definio
2.2.1, ento teramos v ("] Xu e o valor de v em T seria menor que o de o, o que
ue[ui]
seria uma contradio. A ssim, o caminho c, se para 1 < i < n, Si ^ q, tornaria A num
autmato no nard, o que uma contradio. D
Proposio 2.2.5 Num autmato nard existe pelo menos um vrtice v com ge(v) =
1 = gs(v).
Demonstrao: Os casos de autmatos com menos de 4 vrtices so triviais. Seja A

um autmato nard com 4 vrtices, s h seis e encontramse enumerados na Figura 2.5
(ver pgina 32) e fcil verificar que todos contm um vrtice v tal que ge(v) = 1
gs(v). Suponhamos que a proposio verdadeira para todos os autmatos nard com
menos de n estados. Seja A um autmato nard com n estados. Se gs(ini) = 1 e sendo
v tal que o arco (ini, v) existe, ento o subautmato que se obtm pela remoo de ini
nard (considerando v o novo ini) e tem n l estados, donde, por hiptese de induo
se conclui que este subautmato contm um vrtice nas condies da proposio. O
29
autmato A contm portanto um estado nas condies da proposio (o mesmo). Por
um raciocnio anlogo se pode concluir que se em A, ge(firi) = 1, ento A contm
um estado nas condies da proposio. Suponhamos, portanto, que gs(ini) = m e
ge(fin) = n, com m, n > 1.
Sejam ui,...,um, [/, XUi e R como definidos acima. Seja [u\\ uma classe de
equivalncia de R e analisemos os seguintes casos:
1. [ui] tem apenas um elemento U\. Seja Y = XUl U {fin}. Seja A' o subautmato
definido pelos vrtices em Y (sendo U\ o estado inicial de A' e fin o estado final).
(a) Por U\ ser o nico elemento de [u\] (significa que 5+(U,V) = 0, para Uj G
U \ {u\} e v XU1), temos que, em A', apenas fin e U\ podem ter grau de
entrada menor do que em A.
(b) Por u\ ser o nico elemento de [u\] (significa que 6+(u\,v) 0, para M, e
U\{u\} e v e XUi), temos que, em A', nenhum estado tem grau de sada menor
do que em A.
Pela definio de XU1 conclui-se que A' til; pode igualmente concluir-se que
A' acclico e tambm que A nard (por ser subgrafo de um grafo nard no
so acrescentados caminhos). A' um autmato nard com menos de n estados
pelo que, por hiptese de induo, tem um estado nas condies da proposio e
este estado existe em A com o mesmo grau de entrada e sada, por (a) e (b) (se
A' tiver apenas os estados u\ e fin, conclui-se que em A, U\ est nas condies
da proposio).
2. [u\\ tem mais do que um elemento. Seja q G (~) Xu o estado com menor valor
ue[ui]
numa ordem topolgica T em A, de entre os que obedecem s mesmas condies.
Seja Zq como na Proposio 2.2.4 e Y = Zq U {ini, q). Seja A' o subautmato
definido pelos vrtices em Y, sendo ini o estado inicial de A' e q o seu estado
final. Pela definio de Xu e pela Proposio 2.2.4 pode concluir-se que A' til;
fcil concluir que A acclico e, sendo subgrafo de um grafo nard, A' nard.
Temos ainda que:
(a) Se existisse u, U \ [ui] tal que +(UJ,V) ^ 0 com v 6 Y ento ter-se-ia

Ui G [ui] o que absurdo, pelo que em A', nenhum estado tem grau de entrada
menor do que em A.
30
(b) Pela Proposio 2.2.4 temos que, em A', apenas ini e q podem ter grau de
sada menor do que em A, uma vez que em A todos os caminhos, de qualquer
antecessor de q, para fin passam por q.
A' um autmato nard com menos de n estados, pelo que, por hiptese de
induo, tem um estado nas condies da proposio e este estado existe em A
com o mesmo grau de entrada e sada, por (a) e (b).
Teorema 2.2.1 Seja A = (Q, E, ini, 6, fin) um autmato em forma nard. E possvel
aplicar a A o algoritmo da eliminao de estados, removendo em cada passo um
estado q tal que ge(q) = 1 = gs(q) e estes autmatos so os nicos para os quais
esta propriedade se verifica.
Demonstrao: Pela Proposio 2.2.5, A tem pelo menos um estado q nas condies
do teorema. Se removermos q obtemos um autmato A' que ainda se encontra em
forma nard pois no acrescentamos em A nenhum caminho que possa formar um grafo
Jhomeomorfo a D. Por A ainda se encontrar em forma nard ele possui um vrtice q' nas
condies do teorema ou tem apenas dois estados, terminando o processo. Podemos
aplicar o mesmo raciocnio a A' e concluir a veracidade da propriedade indicada no
teorema.
Suponhamos agora que aplicamos o AEE a um autmato que tenha um subgrafo

homeomorfo a D. Em algum passo do AEE teremos de eliminar um dos vrtices
i> U2, U3 ou 1*4 da definio do grafo D (Definio 2.2.3) e qualquer um destes vrtices
tem grau de entrada ou de sada superior a l e este grau no se reduz a 1 pela eliminao
de outros vrtices que no i, 112, U3 ou it4, pois, para que a linguagem reconhecida no
se altere, tero de continuar a existir os caminhos entre os vrtices ui,U2,us e 4 da
Definio 2.2.3, pelo que os autmatos nard so os nicos para os quais a propriedade
indicada se verifica. D
2.3 Implementao
Nesta seco, nas complexidades apresentadas, n significa sempre o nmero de vrtices

do grafo em causa. Seja IsAcyclicGraph uma funo GAP para decidir se um grafo
31
~0-KD-Mj>
a _\ ' J c
Figura 2.5: Autmatos nard de 4 estados
32
dado pela sua lista de adjacncias acclico [KR99]. Esta funo tem complexidade
0(n2). Seja ExistsPathvltov3Withoutv2 uma funo GAP para decidir se num grafo
dado pela sua lista de adjacncias existe um caminho de um vrtice vi para um vrtice
3 que no passe por um vrtice V2- Esta funo tem complexidade G(n). Seja
DescendentsOfVertex uma funo GAP que, para um grafo dado pela sua lista de
adjacncias e um vrtice v\ devolve a lista dos descendentes de V\. Esta funo tem
complexidade 0(n2). Seja ReverseOf Graph, uma funo GAP que, para um grafo dado
pela sua lista de adjacncias devolve a lista de adjacncias do grafo que tem os sentidos
dos arcos invertidos. Esta funo tem complexidade 0(n2).
Na Figura 2.6 apresentamos uma funo GAP que, para o grafo, dado pela sua lista
de adjacncias, subjacente a um autmato com apenas um estado final, decide se o
grafo nard. Esta funo, alm do grafo subjacente, tem como input o estado inicial
e o estado final do autmato. Pelas linhas de cdigo seguintes podemos ver que esta
funo tem complexidade 0(n5).
for i in l i s t do
for j in Difference(list, [i]) do
if ForAlKinter, x -> ExistsPathvltov3Withoutv2(G,ini,j,x)) then
fi;
od;
od;
em que l i s t a lista de vrtices do grafo excepto ini e fin, Difference ( l i s t , [i] )

l i s t sem o vrtice i, inter a lista dos vrtices que so descendentes co-
muns dos vrtices i e j e para todos os vrtices x em inter feito o teste
ExistsPathvltov3Withoutv2(G,ini,j,x).
Na Seco A.2 (ver pgina 99) apresentamos uma verso do AEE especfica para o
caso de o AF de input ser nard e esta funo tem complexidade 0(kn3), em que n o
nmero de estados do AF de input e k =| |. Este valor dominado pela converso do
AF inicial no seu AFE associado e esta complexidade deve-se s razes apresentadas
na Seco 1.1.7.1 (ver pgina 17) para a complexidade da funo computeGTG. Se o
33
IsNardGraph := function(G,ini,fin)
local v, n, i, j , k, list, inter, Gr, flag;
flag := false;
if IsAcyclicGraph(G) then
n := Length(G);
list := Difference([i..n], [ini.fin]);
for i in list do
for j in Difference(list, [i]) do
if ExistsPathvltov3Withoutv2(G,i,j,0) and
ExistsPathvltov3Withoutv2(G,ini,i,j) and
ExistsPathvltov3Withoutv2(G,ini,j,i) and
ExistsPathvltov3Withoutv2(G,i,fin,j) and
ExistsPathvltov3Withoutv2(G,j,fin,i) then
Gr := ReverseOfGraph(G);
inter := Intersection(
DescendentsOfVertex(G,i),
DescendentsOfVertex(Gr,j));
if ForAll(inter, x ->
ExistsPathvitov3Withoutv2(G,ini,j,x)) then
return(false);
fi;
fi;
od;
od;
return(true);
else
return(false) ;
fi;
end;
Figura 2.6: Verifica se um grafo nard
34
input fosse j o AFE, ento a funo teria complexidade 0(kn2), pois este tamanho
mximo das expresses calculadas. A expresso resultado tem tamanho linear no
nmero transies do autmato inicial.
NardFAtoRatExp := function(A)

while Q > 0 do
for i in [3. .QJ do
if Nin[i] = 0 or Nout[i] = 0 or
(Nin[i] = i and Nout[i] = 1) then
destroyState(i);
break;
fi;
od;
od;
# Devolve a expresso resultado . . .
end;
Figura 2.7: NardFAtoRatExp
2.4 Autmatos de Thompson
Os autmatos de Thompson so aqueles que so obtidos pelo algoritmo de Thompson

[Tho68] a partir de uma expresso regular e cuja caracterizao se encontra em
[GPW99]. Os autmatos de Thompson tm, entre outras caractersticas, apenas um
estado inicial I com ge(I) = 0 e um estado final F com gs(F) = 0. Os autmatos de
Thompson de 0, c e a G S so apresentados nas Figuras 2.8, 2.9 e 2.10 respectivamente.
35
-
Figura 2.8: Autmato de Thompson de 0
--
Figura 2.9: Autmato de Thompson de e
--MD
Figura 2.10: Autmato de Thompson de a
Os autmatos de Thompson que representam a unio e concatenao de duas

expresses ri e r<i so apresentados nas Figuras 2.11 e 2.12, respectivamente e em que
os estados I\ e F\ (I2 e F2) so respectivamente o estado inicial e final do autmato
de Thompson que representa a expresso ri (r 2 ).
Figura 2.11: Autmato de Thompson representando uma unio
36
Figura 2.12: Autmato de Thompson representando uma concatenao
O autmato de Thompson que representa o fecho de Kleene de uma expresso ri

encontra-se representado na Figura 2.13.
Figura 2.13: Autmato de Thompson representando o fecho de Kleene
A construo do autmato de Thompson que representa uma expresso regular r

procede do seguinte modo [ASU86]:
1. se r = 0 ou r e ou r = a, a e S ento constri-se o autmato da Figura 2.8 ou

2.9 ou 2.10 respectivamente;
2. se r = ri + r 2 ent,o constroem-se os autmatos para ri e r 2 e usa-se o autmato

da Figura 2.11 para representar r, em que I\ e F\ {h e F2) so respectivamente
o estado inicial e final do autmato que representa ri (r2);
3. se r = rir 2 ento constroem-se os autmatos para ri e r 2 e usa-se o autmato

da Figura 2.12 paira representar r, em que I\ e F\ (72 e F2) so respectivamente
o estado inicial e final do autmato que representa ri (r2);
4. se r = ri ento constri-se o autmato para ri e usa-se o autmato da Figura

2.13 para representar r, em que I\ e F\ so respectivamente o estado inicial e
final do autmato que representa ri.
37
Proposio 2.4.1 Os autmatos de Thompson de linguagens finitas so nard.
Demonstrao: As linguagens finitas so representadas por expresses regulares que

no contm o fecho de Kleene. Vamos provar a proposio por induo no nmero de
estados do autmato de Thompson. Os casos base so os das Figuras 2.8 a 2.10 e estes
so nard. Suponhamos agora que a proposio vlida para todos os autmatos de
Thompson, que representam linguagens finitas, com menos de n estados e seja A um
autmato de Thompson, de uma linguagem finita, com n estados. Por a linguagem
ser finita, no ltimo passo da construo de A foi usado o autmato da Figura 2.11
ou 2.12 para juntar num s autmato dois autmatos de Thompson Ai e Ai. Por
hiptese de induo, os subautmatos Ai e A2 so nard (tm menos de n estados).
Ao agrupar estes dois autmatos num nico que representa L(Ai) U L{A-i), usando a
construco da Figura 2.11, vemos que no acrescentado nenhum arco, no autmato
resultante, que forme um subgrafo homeomorfo a D. Igualmente, para o autmato
que representa L{A\)L{A<i), usando a construco da Figura 2.12, no acrescentado
nenhum arco, no autmato resultante, que forme um subgrafo homeomorfo a D. O
2.5 Concluses
Se durante a aplicao do AEE removermos um vrtice v tal que ge(v) = 1 e gs(v) = 2

estamos a duplicar a ocorrncia, na expresso regular final, da etiqueta do arco que
entra em v (ver Figura 2.14), porque, seja u tal que (u, v) ^tyepeq tais que S(v, p) ^
0 e (v, q) 7^ 0, com a remoo de v estamos a substituir u e o s arcos que nele incidem
(entram e saem) pelos arcos tais que S(u,p) = S(u,v)6(v,p) e (u, q) = 6(u,v)S(v,q)
(ver Figura 2.15).
wJC^
Figura 2.14: Remoo de um vrtice v tal que ge(v) = 1 e gs(v) = 2
38
Figura 2.15: Aps a remoo de v
O nico caso em que no acontece uma repetio de duas ou mais vezes de etiquetas
de arcos o caso da remoo de um vrtice v tal que ge(v) = 1 = gs(v) (Figuras 2.16
e 2.17).
Figura 2.16: ge(v) 1 = gs(v)
Figura 2.17: Aps a remoo de v
Em qualquer passo do AEE o tamanho da expresso final ser sempre superior ou

igual soma dos tamanhos das etiquetas dos arcos presentes nesse passo, uma vez
que a aplicao de um passo do AEE no faz diminuir a soma anterior remoo de
um vrtice v, fazendo-a aumentar sempre, excepto no caso em que ge(v) = 1 = gs(v),
como veremos na Seco 3.1.
A verso do AEE para o caso nard (Seco A.2, ver pgina 99) tem como output a
expresso regular equivalente e de menor tamanho obtenvel pelo AEE para o autmato
em causa, uma vez que em nenhum passo foi duplicada a etiqueta de algum arco. Neste
caso o tamanho da expresso final seria igual ao nmero de arcos do autmato de input
e neste sentido que dizemos que a ordem de remoo ptima.
O problema de encontrar uma expresso mnima obtenvel pelo AEE para um

autmato nard resolvido em tempo linear no nmero de transies do AF inicial
(assumindo que o input j o AFE associado ao AF dado, uma vez que esta converso
39
tem complexidade 0(kn3) usando as representaes GAP que temos vindo a referir)
e neste sentido que dizemos que a ordem ptima de remoo pode ser encontrada,
neste caso, de forma eficiente.
Para terminar, consideremos o autmato no nard da Figura 2.18.
Figura 2.18: Autmato no nard
Neste autmato, consideramos ini = 1 e fin = 5 e a nica ordem ptima de remoo

2,4, 3. A expresso obtida pelo AEE para esta ordem de remoo r = (ad + b)(fh +
g) + (ae + c)h.
O autmato da Figura 2.19 um autmato nard equivalente ao autmato que estamos

a considerar e mnimo no nmero de transies de entre os outros autmatos nard
equivalentes, porque foi construdo a partir de uma expresso minimal obtenvel pelo
AEE para o autmato da Figura 2.18, usando o algoritmo de Thompson e simplificando
as transies por e.
Figura 2.19: Autmato nard equivalente
Pelo que foi dito antes, deste autmato nard possvel encontrar de forma eficiente
a ordem ptima de remoo para obter a expresso r, pelo que, em trabalho futuro,
40
gostaramos de tentar resolver o Problema 2.5.1
Problema 2.5.1 (Autmato nard mnimo equivalente)
Dado um autmato A, acclico e com apenas um estado final, qual um autmato
nard A' tal que L(A') = L(A) e A' mnimo no nmero de transies?
Este problema equivalente ao de encontrar uma expresso regular de tamanho

mnimo que represente uma dada linguagem regular, pois, dada uma expresso regular
possvel encontrar um autmato nard tal que, removendo em cada passo do AEE
um estado com grau de entrada e sada 1 se obtm a expresso inicial. Este autmato
nard ter um nmero de transies igual ao tamanho da expresso, portanto, se
conseguirmos obter um autmato nard mnimo em transies que reconhea uma dada
linguagem regular, conseguiremos obter a partir dele em tempo linear uma expresso
que ser de tamanho mnimo, pois se houvesse uma menor, existiria um autmato
nard que reconheceria a mesma linguagem e teria menos transies.
41
Captulo 3
U m a heurstica para o caso geral
Neste captulo apresentamos uma heurstica para o problema de encontrar uma ordem
ptima de remoo dos vrtices para o caso de um autmato arbitrrio. Esta heurstica
surgiu no decurso dos trabalhos de estgio da licenciatura e foi apresentada em [DM04].
3.1 Pesos
Introduzimos a noo de peso de um AFE A = (Q, 3D, S, o, F) como sendo
Q Q
-p(A) = ]T Y, tamanho(S(i,j)) - E
i=i j = i
em que E o nmero de transies etiquetadas por e (no contamos estas etiquetas,

pois, sendo sempre feita a simplificao re = r este peso nem sempre estar presente
na expresso final) e de peso de um vrtice v como sendo
V(v)=V(Al)-V(A)
em que Ai o AFE resultante da remoo de v em A pelo AEE, donde se conclui que
V{Ai) = T{A) + V(v)
e em particular podemos notar que o tamanho da expresso regular, resultado do AEE,

ser V(An) em que An o AFE com apenas os estados ini e fin.
43
Como vimos na Seco 2.5, os nicos vrtices v tais que V(v) = 0 so aqueles para os
quais ge(v) 1 = gs(v). Mais precisamente, o peso de um vrtice v pode ser calculado
pela frmula:
P()= ( / ( M x M ) - i ) ) +
peJSv
( / ( , )xfoe(i;)-l))+ (3.1)
fc(v) x (0e(v) x ps(u) - 1),
em que:
Ev = {u\ueQ/\ 6(u, v) ^ 0},
Sv = {u | u e Q A <5(t>, ) 7^ 0},
/ : Q x Q > N tal que / ( p , ) = tamanho((p, q)) e
/i : Q > N tal que h(q) = tamanho(6(q, q)).
3.2 Heurstica
A heurstica consiste em eliminar, em cada passo do AEE, um vrtice v que minimize

V(v), uma vez que o tamanho da expresso regular resultado ser igual soma do
peso do AFE inicial com o peso com que cada vrtice removido. V(v) cresce com
ge(v), gs(v) e os tamanhos das etiquetas. A eliminao de um vrtice pode diminuir,
preservar ou aumentar o nmero de arcos do AFE resultante, em relao ao AFE
anterior. Seja v o vrtice a eliminar e A\ o AFE resultante da remoo de v de A, o
nmero de arcos em A\
Narcos(A\) = Narcos(A) - ge(v) gs(v) + ge(v) x gs(v). (3.2)
Em face da Equao 3.2, vemos que o nmero de arcos se mantm apenas se
ge(v) x gs(v) = ge(v) + gs(v),
ou seja,s acontece a igualdade se ge(v) = 2 e gs(v) = 2.
Resumindo, se
44
ge(v) 1 (ou gs(v) = 1) ento o nmero de arcos vai diminuir com a remoo
do vrtice;
ge(v) = 2 e gs(v) = 2 ento o nmero de arcos mantm-se;
ge(v) > 2 e gs(v) > 1 (ou vice-versa) ento o nmero de arcos vai aumentar com
a remoo do vrtice.
A heurstica favorece a escolha de um vrtice que minimize o nmero de arcos criados

pela sua remoo, fazendo com que o peso de alguns vrtices possa diminuir aps a
remoo do vrtice escolhido. De notar que o tamanho da expresso final ser a soma
do peso do AFE inicial com o peso de cada vrtice quando removido.
3.3 Alguns Resultados Experimentais
Comemos por aplicar o AEE sem heurstica a 512 autmatos diferentes, teis,
gerados aleatoriamente de 4, 5, 6 e 7 estados, obtendo os resultados da Tabela 3.1
Tabela 3.1: Alguns Resultados sem Heurstica
Estados N Devolveu a min. Mdia de erro Mdia do tamanho min.

4 512 19,5% 13 25
5 512 3,3% 54 55
6 512 0,78% 219 115
7 512 0% 963 269
em que as colunas tm o seguinte significado:
1. N: nmero de autmatos;
2. Devolveu a min.: percentagem de casos em que foi devolvida uma expresso de

tamanho mnimo;
45
3. Mdia de erro: mdia da diferena entre o tamanho da expresso devolvida e o
tamanho mnimo, considerada apenas nos casos em que h diferena; e
4. Mdia do tamanho min.: mdia do tamanho da expresso mnima nos casos

considerados em 3.
Na Tabela 3.2 temos os valores para os mesmos autmatos, mas usando a heurstica
descrita.
Tabela 3.2: A lguns Resultados com Heurstica
Estados N Devolveu a min. Mdia de erro Mdia do tamanho min.

4 512 64,3% 4 25
5 512 44,5% 8 54
6 512 29,5% 14 111
7 512 24,0% 32 256
Apresentamos ainda, na Tabela 3.3, resultados obtidos com autmatos obtidos a partir
do grafo de Cayley de alguns monides de transformaes. O grafo de Cayley de um
monide M um grafo em que, para x,y M o arco (x, y) est presente se e s se
existir um gerador a de M tal que x-a = y eno autmato construdo a partir do grafo
de Cayley de M a etiqueta do arco (x, y) a.
Sejam k\, fa,..., kn G { 1 , . . . , n } U { # } . Denotamos por [ki, k2, ., kn] a funo parcial
/ de { 1 , . . . , n} em si mesmo, tal que para todo i e { 1 , . . . , n}, f(i) = ki se ki ^ # e
f(i) no est definida caso contrrio.
Consideraremos os seguintes monides:
VO U gerado por [#, 1,2,3], [1,2,4, # ] , [1,3, # , 4] e [2, # , 3,4];
V015: gerado por [#,1,2,3,4], [1,2,3,5,#], [1,2,4, # , 5 ] , [1,3, # , 4 , 5 ] ,

[2, # , 3 , 4 , 5 ] ;
46
VOVl4: gerado por [2,3,4,1] e [1,2,4, #];
VOVl5: gerado por [2,3,4,5,1] e [1,2,3, 5, #].
Na Tabela 3.3, Min(M[q0,f]) o autmato determinstico mnimo equivalente ao

autmato que tem como grafo subjacente o grafo de Cayley do monide M e
considerando o estado Q como inicial e o estado / como o nico estado final. Os tempos
dos resultados obtidos, sem e com heurstica, so da mesma ordem de grandeza.
Tabela 3.3: Tamanhos das expresses para alguns Grafos de Cayley
Autmato Estados Alfabeto Sem heurstica Com heurstica

VOI4[1,20] 70 4 12657 870
Min(VlA[l, 20]) 16 4 1807 491
V015[l, 125] 252 5 89456164 47532
Min(V015[l, 125]) 32 5 107438 8602
POPX4[1,60] 141 2 5027 1344
Min(VOVl4 [1,60]) 33 2 8381 704
VOVl5[l,70] 631 2 1810719 43319
Min{VOVl*,[l, 70]) 81 2 398620 11528
Foi tambm desenvolvida uma verso melhorada da heurstica e cujos resultados para
os autmatos mnimos da tabela anterior apresentamos na Tabela 3.4. Nesta tabela lk
e nv so parmetros da verso melhorada [DM04]. Consideremos uma rvore em que
a raiz o AFE inicial e cada descendente directo da raiz o AFE obtido pela remoo
de um vrtice diferente, do AFE inicial. Cada descendente directo de cada um dos ns
anteriores o AFE obtido pela remoo de um vrtice diferente, do AFE representado
pelo n pai. As folhas desta rvore representam o AFE com apenas os estados ini e fin
para todas as ordens de remoo possveis e se fosse possvel calcul-la completamente,
bastaria escolher, de entre as folhas, aquela que representasse a expresso regular de
menor tamanho, sendo esta um expresso de tamanho mnimo obtenvel pelo AEE.
Dada a intratabilidade do clculo de toda esta rvore, os parmetros lk e nv permitem
tratar uma rvore de menor tamanho, da seguinte forma:
47
1. Ik: representa o nmero de nveis da rvore que iremos calcular e
2. nv: em vez de cada n da rvore ter tantos descendentes directos como vrtices
tem o AFE representado por esse n, este parmetro permite definir que cada
n ter apenas nv descendentes directos; sero os definidos pela remoo dos nv
vrtices de menor peso.
Ao fim de lk nveis da rvore ser escolhido para remoo o vrtice cuja remoo
deu origem ao AFE representado por um descendente directo da raiz da rvore que
pertence a um caminho da raiz a uma folha que representa um AFE de menor peso.
Os tempos foram medidos num Pentium 2,6GHz.
Tabela 3.4: Tamanhos das expresses com a heurstica melhorada
Autmato Heurstica melhorada lk nv Tempo (segundos)

Min(VOIi[l,20]) 286 7 4 4
Min(VOX5[l, 125]) 5269 7 4 21
MiniVOVl^m}) 423 5 4 3
Min(VOVl5[l,70]) 7874 5 4 81
3.4 Implementao
Na Seco A.3 (ver pgin 107) apresentamos a funo GAP que implementa a heurstica
descrita neste captulo.
A funo computeGTG semelhante apresentada na Seco 1.1.7.1, apenas com a

diferena de que aqui so calculadas duas listas, I n v e r t i c e s e O u t v e r t i c e s que
guardam, para cada estado v, os estados u tais que 5(u, v) ^ 0 e (v,u) ^ 0
respectivamente. Esta funo executada uma nica vez e tem complexidade 0(kn3),
pelas razes apresentadas na Seco 1.1.7.1 (ver pgina 17), no caso de o input
ser um AFND ou um AFNDTE e 0(kn2) no caso de um AFD, em que n o
48
FAtoRatExp := functioii(A)

# . . . Cdigo para a remoo imediata dos

# estados v t a i s que ge(v) = 1 = gs(v) ...
while Q > 0 do
V := computeBestO ; # Calcula o "melhor"
# v r t i c e a ser removido
# . . . Cdigo para a c t u a l i z a r e s t r u t u r a s de dados . . .

destroyLoop(V); # Elimina o lacete do estado V
destroyState(V); # Elimina o estado V
od;
# . . . Devolve a expresso resultado . . .
end;
Figura 3.1: AEE com heurstica para o caso geral
nmero de estados do AF inicial e k = | E |. A funo destroyLoop executada

n vezes e tem complexidade 0(knin), pelas razes apresentadas na Seco 1.1.7.1. A
funo d e s t r o y S t a t e executada n vezes e tem complexidade 0(n2kAn), pelas razes
apresentadas na Seco 1.1.7.1. A funo computeWeight executada no mximo n 2
vezes e tem complexidade 0(n). A funo computeBest executada n vezes e tem
2
complexidade 0(n ), pelo que o algoritmo tem complexidade 0(n3k4n).
3.5 Concluses
Nem sempre a heurstica apresentada conduz obteno da expresso regular de

tamanho mnimo obtenvel pelo AEE. Consideremos de novo o autmato apresentado
na Figura 3.2. Na Tabela 3.5 apresentamos o peso do AFE e de cada vrtice.
49
--
Figura 3.2: Autmato A
Tabela 3.5: Pesos Iniciais
Peso
AFE 7
1 3
2 3
3 7
4 1
Nas Figuras 3.3 a 3.6 apresentamos os vrios passos do AEE removendo em cada passo
um dos vrtices de menor peso e nas Tabelas 3.6 a 3.8 os pesos associados.
GH-
~ J -
Tabela 3.6: Pesos no autmato A depois de removido o vrtice 4
Peso
AFE 8
1 4
2 3
3 11
50
ab + ba
Tabela 3.7: Pesos no autmato A depois de removidos os vrtices 4 e 2
Peso
AFE 11
1 6
3 7
ab + ba-h (aa(b + aa))

b + aaa
Tabela 3.8: Pesos no autmato A depois de removidos os vrtices 4, 2 e 1
Peso
AFE 17
3 0
0
a + (6 + aa)(ab + ba + (aa(b + aa)))* (b + aaa)

51
Reparamos assim que o tamanho da expresso obtida usando a heurstica apresentada
tem tamanho 17. A expresso mnima obtenvel pelo AEE para este autmato tem
tamanho 16 e a sua obteno foi ilustrada nas Figuras 1.4 a 1.7 (ver pgina 20).
Apresentamos nas Tabelas 3.9 a 3.11 os pesos associados em cada passo.
Tabela 3.9: Pesos no autmato A depois de removido o vrtice 2
Peso
AFE 10
1 5
3 12
4 1
Tabela 3.10: Pesos no autmato A depois de removidos os vrtices 2 e 1
Peso
AFE 15
3 16
4 1
Tabela 3.11: Pesos no autmato A depois de removidos os vrtices 2, 1 e 4
Peso
AFE 16
3 0
Podemos ver na Tabela 3.12 os pesos com que cada vrtice foi removido em cada uma
das duas ordens de remoo anteriores.
Tabela 3.12: Peso com que cada vrtice foi removido
1 2 3 4
4, 2, 1, 3 6 3 0 1
2, 1, 4, 3 5 3 0 1
52
Representamos por Vv(u) o peso do vrtice u depois de removido o vrtice v. Pode,
assim, dar-se o caso de, para um AFE no decurso do AEE, existirem vrtices v, u e z
tais que V(v) < V(u) < V(z) e em que aps a remoo de v tenhamos Vv(u) V(u) e
'Pv(z) = V(z) + me aps a remoo de u tenhamos Vu{v) = V(v) e Vu(z) = V{z) + n
e estes valores tais que V(v) + Vv{u) + Vvu(z) > V{u) + Vu(v) + Vuv(z).
53
Captulo 4
U m a heurstica para o caso acclico
Neste captulo apresentamos uma heurstica para a escolha do melhor vrtice a ser
removido em cada passo do AEE, que especfica para o caso de autmatos acclicos e
que tem resultados substancialmente melhores que os da heurstica para o caso geral.
4.1 Motivao
Se aplicarmos o AEE a um autmato sem preocupao com a ordem de remoo

dos vrtices podemos obter como resultado uma expresso regular de tamanho
muito superior ao tamanho mnimo obtenvel pelo AEE. Por exemplo, para
o autmato de 16 estados (ver Seco 3.3, pgina 45) Min(VOTG[l,5Q]) em
que VOX% gerado por [1,2,3,4,5,6, #], [#, 1,2,3,4,5, #], [1,2,3,4,6,#,#],
[1,2,3,5,#,6,#], [1,2,4, #,5,6, #4], [1,3,#,4,5,6,#] e [2, #,3,4,5,6, #], o pro-
grama AMoRE [MMP+95], que no inclui uma escolha especial do vrtice a remover,
produz uma expresso com tamanho 157675, ao passo que a heurstica melhorada
(apresentada no fim da Seco 3.3) com parmetros lk 7 e nv = 4 produz uma
expresso equivalente de tamanho 394 (em 3 segundos)!
A heurstica apresentada neste captulo tenta obter subexpresses da expresso final

da forma ri(r2+r 3 ) ou (?'i+r 2 )r 3 em vez de, respectivamente, rir2+rir 3 ou rir 3 +r 2 r 3 e
estas duas simplificaes so as nicas que ocorrem no caso acclico (alm de ri+r2 = r2
se r\ T2, que no tratmos dada a complexidade da verificao da incluso), pois
nestes casos no h a presena do operador *.
55
4.2 Heurstica
A verso do AEE que implementmos para o caso acclico comea por remover todos
os estados q tais que ge(q) = 1 = gs(q). Em seguinda, se ainda houver vrtices por
remover, aplica a heurstica para escolher o prximo vrtice a ser removido. Nesta
heurstica, a funo computeWeight(q) calcula o peso do estado q de acordo com a
Equao (3.1) (ver pgina 44), que denotamos por V(q). A funo computeWDist(q)
calcula o peso que ser "poupado" pela remoo de q, ou seja, com a remoo de q
estamos a construir uma subexpresso da expresso final da forma (ri H \- rn)(si +
1- sm) em vez de r\8\ H h rism H h rns\ -\ f- rnsm. Esta funo identifica,
para um estado q, estados i e j tais que os arcos (i,q),(q,j) e (i,j) existem. Para
cada par i, j encontrado, adiciona a um contador w o tamanho da etiqueta de cada
arco que entra em i e em seguida o tamanho das etiquetas dos arcos que partem de
j e retorna o valor deste contador. Na Figura 4.1 vemos um grafo etiquetado nestas
condies.
Figura 4.1: Grafo Etiquetado
Se, neste grafo, removermos q (supondo que os estados 4 e 5 no esto presentes),
56
passamos a ter gs(i) = 1, como se pode ver na Figura 4.2.
Figura 4.2: Grafo Etiquetado depois de removido q
Nestas condies estaremos a obter a subexpresso (a + b)(ce + d) em vez de, se

removssemos o vrtice i, ad + ac + bd + bc.
Na funo computeWDist (q) tambm calculado o valor de um bnus,que se pretende

mximo. Este bnus reflecte o facto de, ao remover q, estarmos a reduzir o peso de
outro vrtice a 0, ou seja, "ganhamos" o peso desse vrtice antes da remoo de q, pois
como j vimos, a remoo de um vrtice de peso 0 no faz aumentar o tamanho da
expresso final. No grafo da Figura 4.1 suponhamos que o estado 4 no est presente,
ou seja, ge(q) = 1, neste caso, o bnus de q seria aumentado de V(j), pois com a
remoo de q teramos, no autmato resultante, V(j) = 0, ou seja, o vrtice j seria
removido com peso 0, o que, como j vimos, o ideal para a obteno de uma expresso
com o menor tamanho.
Formalmente, seja
Xq = {(i,j) | i,j e Q,6(i,q) # 0,%,j) 0 e 6(i,j) # 0},
para cada (i, j) 6 Xq sejam

=
khj) {u I u e
Qe ^(ui 0/0})
SI(ij) = ^2 tamanho((u,i)),
57
0(Hj) = {v\veQe S(j, v) # 0}
e
SO(ij) X] tamanho(S(j,v)),
ento
^()= E si{iJ) + so{i:j).
{i,j)exq
Na Figura 4.3 apresentamos o cdigo da funo computeWDist().
Podemos notar que, removendo o vrtice q (Figura 4.1) diminumos de 1 o nmero de

arcos que partem de i (se Nout[q] = 1, ou seja, gs(q) = 1). Esta diminuio faz com
que para V(i) no contribua a quantidade SIaj).
Simetricamente, removendo q, diminuimos em 1 o nmero de arcos que entram em j

(se Nin[q] = 1, ou seja, ge(q) 1), pelo que para V(j) no contribui a SO^jy
Assim, aparentemente, faz sentido que se tente escolher para remoo, um vrtice que
maximize WD(q), pois isso pode significar diminuio no nmero de subexpresses
repetidas no resultado, uma vez que podemos estar a diminuir gs(i) e/ou ge(j).
Na funo computeDistGain(q), para estados q e t tais que existe o arco (q, t) e se

para todos os vrtices p tais que se o arco (p, q) existe, ento existe o arco (p, t),
associa-se ao estado t o valor de gs(t), pois se removermos q nestas condies, o grau
de entrada de reduz-se em uma unidade, diminuindo assim o peso de t. O valor assim
associado por esta funo ao estado t guardado em d i s t _ g a i n [ t ] . Formalmente,
sejam
Eq = {u\uGQ e (u, q) ^ 0},
Sq = {u | u e Q e S(q, u) ^ 0},
ento, para cada t G Sq
dist-gain[t] = dist-gain[t] + gs(t)
se Vs Eq(t Ss) e, inicialmente, dist.gain[t] = 0 para todos os t G Q.

Simetricamente, para cada s Eq
dist-gain[s] dist-gain[s] + ge(s)
se Vi e Sq(s e Et).
58
computeWDist := function(q)
local i, j, k, w;
w := 0;
# Invertices[q] a lista de estados p tais que o arco
# (pq) existe
# Outvertices[q] a lista de estados p tais que o arco
# Cq>p) existe
# Nin[q] |Invertices[q]I = ge(q)
# NoutCq] IOutvertices[q]I = gs(q)
# WT[k][i] tamario(delta(k,i))
f o r i i n I n v e r t i c e s [ q ] do
f o r j i n O u t v e r t i c e s [ q ] do
if j in OutverticesCi] then
i f Nout[j] = 1 and N i n [ j ] = 2 and Nin[q] = 1 t h e n
bonus[q] := bonus[q] + computeWeight(j);
fi;
i f NoutCi] = 2 and N i n [ i ] = 1 and Nout[q] = 1 t h e n
bonus[q] := bonus[q] + computeWeight(i);
fi;
f o r k i n I n v e r t i c e s [ i ] do
w := w + WT[k] [ i ] ;
od;
f o r k i n O u t v e r t i c e s [ j ] do
w := v + W T [ j ] [ k ] ;
od;
fi;
od;
od;
return(w);
end;
Figura 4.3: computeWDist()
59
computeDistGain := function(q)
local s, t ;
dist_gain := L i s t ( [ l . . Q ] , x->0);
for t in Outvertices[q] do
if ForAll(Invertices[q], i -> t in Outverticesfx]) then
dist_gain[t] := d i s t _ g a i n [ t ] + Nout[t];
fi;
od;
for s in Invertices[q] do
if ForAll(Outvertices[q] , x -> s in Invertices[x3) then
dist_gain[s] := dist_gain[s] + Nin[s];
fi;
od;
end;
Figura 4.4: computeDistGain()
Na Figura 4.4 apresentamos o cdigo da funo computeDistGain().
Para a escolha do estado a ser removido construda, na funo computeBestO, uma

lista l = {(vai, i) | i Q e vai WD(i) V(i) + bonus[i]}. Esta lista ento ordenada
por valor crescente do primeiro elemento de cada par membro da lista (se dois pares
tiverem o primeiro elemento igual ento a ordenao feita pelo segundo elemento, ou
seja, o nmero do estado). Sejam s o segundo elemento do penltimo par desta lista
e o segundo elemento do ltimo par desta lista. Em seguida chamada a funo
computeDistGain(s) e dg a lista dist-gain assim calculada. Como passo seguinte
chamada a funo computeDistGain(t), ficando calculada nova lista dist-gain. Se
com a remoo de s o valor de dg[t] for superior ao valor de dist-gain[s] se removido
o vrtice t, ento removido o vrtice s, caso contrrio removido o vrtice t.
A funo de escolha apresentada na Figura 4.5, onde Q o nmero de estados do

AFE.
60
computeBest := functionO
local i , j , 1, s, t , dg;
if Q = 2 then
return(l);
fi;
bonus := L i s t ( [ l . . Q ] , x->0);
1 := [ ] ;
j := 0;
for i in [3..Q] do
AddSetd, [computeWDist(i)-computeWeight(i) + bonus [ i ] , i ] ) ;
j := j + 1;
od;
if j > 1 then
s := l [ j - l ] [ 2 ] ;
t := l [ j ] [ 2 ] ;
computeDistGain(s);
dg := StructuralCopy(dist_gain);
computeDistGain(t);
if dg[t] > dist_gain[s] then
return(s);
else
return(t);
fi;
else
return(l[j][2]);
fi;
end;
Figura 4.5: computeBest()
61
4.3 Exemplo
Para o autmato da Figura 4.6 (o nmero 847 refere-se a uma enumerao feita por
ns) a nica ordem ptima de remoo 5,3,4,6.
Figura 4.6: Autmato 847
A heurstica apresentada neste captulo basear-se-ia nos valores apresentados nas

Tabelas 4.1 e 4.2 para escolher o primeiro vrtice a ser removido.
62
Tabela 4.1: Valores para escolha do primeiro vrtice a ser removido
i WDfi) V{) bonusfi] WD(i) - V{i) + bonusfi]

3 4 2 0 2
4 4 4 0 0
5 3 2 0 1
6 0 2 0 -2
Tabela 4.2: dist-gain[i]
i dist_gain[i]
3 1
5 0
A escolha feita seria o vrtice 5, uma vez que 3 e 5 so os dois vrtices com maior
valor na ltima coluna da Tabela 4.1 e dist-.gain{5] < dist-gain[3].
O AFE resultante da remoo do estado 5 o da Figura 4.7 e para este AFE mostramos
nas Tabelas 4.3 e 4.4 os valores que orientam a escolha do segundo vrtice a ser
removido.
Tabela 4.3: Valores para escolha do segundo vrtice a ser removido
i WD(i) V(l) bonusfi] WD(i) - V{i) + bonusfi]

3 5 1 3 7
4 2 3 1 0
6 0 2 0 -2
63
Figura 4.7: Autmato 847 depois de removido o estado 5
i dist_gain[i]
3 1
4 1
Aqui seria escolhido o estado 3 para remoo pois o valor da ltima coluna da Tabela
4.3 mximo para este estado e entre 3 e o estado com segundo maior valor nessa
coluna (4) temos dist-gain[3] = dist.gain\4\.
64
Figura 4.8: Autmato 847 depois de removidos os estados 5 e 3
0 AFE obtido depois de remover o estado 3 o da Figura 4.8. A partir deste AFE
no seriam feitas mais escolhas porque o estado 4 seria eliminado imediatamente por
se ter ge(4) = 1 = gs(A) e em seguida seria removido o vrtice 6 pelo mesmo motivo,
tendo sido assim conseguida a ordem ptima de remoo 5,3,4,6.
Neste autmato, a heurstica para o caso geral removeria os vrtices na ordem 3,6,4,5,
resultando numa expresso com mais 1 smbolo que a mnima. Variaes desta
heurstica para o caso acclico foram tentadas, mas com piores resultados.
4.4 Alguns Resultados Experimentais
Para todos os grafos subjacentes de autmatos de 1, 2, 3, 4, 5, 6 e 7 estados,

acclicos, teis e com apenas um estado final foram aplicadas as duas heursticas
descritas, sendo os resultados apresentados nas Tabelas 4.5 e 4.6, onde as colunas
1 a 6 indicam a percentagem de casos em que a expresso devolvida tem mais 1, ...
ou 6 smbolos, respectivamente, do que a expresso mnima e a coluna N indica o
nmero de autmatos considerados.
65
Tabela 4.5: Heurstica para o caso geral
estados N Atingiu min 1 2 3 4 5 6

1 1 100%
2 1 100%
3 2 100%
4 8 100%
5 64 93,8% 6,2%
6 1024 76,4% 20,5% 2,7% 0,4%
7 32768 52,0% 30,7% 11,8% 4,2% 1,0% 0,2% 0,1%
Tabela 4.6: Heurstica para o caso acclico
estados N Atingiu min 1 2 3 4 5 6

1 1 100%
2 1 100%
3 2 100%
4 8 100%
5 64 100%
6 1024 97,5% 2,5%
7 32768 85,5% 12,8% 1,6% 0,1%
66
4.5 Implementao
Na Seco A.4 (ver pgina 111) apresentamos a funo GAP que implementa a
heurstica descrita neste captulo.
AcyclicFAtoRatExp := function(A)

computeGTGO;
removeImediate O ; # Remove os estados v t a i s que
# ge(v) = 1 = gs(v)
while Q > 2 do
q := computeBestO ; # Calcula o "melhor"
# vrtice a ser removido
destroyState(q); # Elimina o estado q
removelmediateO ;
od;
for i in [1..Q] do # Remove os ltimos 2 estados
destroyState(l);
od;
# . . . Devolve a expresso resultado . . .
end;
Figura 4.9: AEE com heurstica para o caso acclico

A funo computeGTG executada uma nica vez e tem complexidade 0(kn3) no caso
de o input ser um AFND ou um AFNDTE, pelas razes apresentadas na Seco 1.1.7.1
e 0{kn2) no caso de um AFD, em que n o nmero de estados do AF de input e
k = | E |. A funo d e s t r o y S t a t e executada n vezes e a sua complexidade
determinada pelas linhas de cdigo seguintes:
for p i n I n v e r t i c e s [ n ] do
67
for q in Outvertices[n] do
. . . Actualizao das etiquetas das transies ...
od;
od;
pelo que, para determinar a complexidade desta funo necessrio majorar o tamanho
das expresses regulares envolvidas. A maior expresso, obtenvel pelo AEE, que
representa a linguagem reconhecida por um autmato acclico consiste numa unio de
concatenaes, que exactamente a unio das expresses que representam um caminho
do estado inicial para um estado final. Esta expresso ter tamanho mximo, para
um autmato acclico de n estados, se o seu grafo subjacente tiver todos os arcos
possveis, pois assim garantido que o nmero de caminhos do estado inicial para
qualquer estado final mximo. A linguagem reconhecida por um autmato de n
estados e com vrios estados finais pode ser reconhecida por um autmato de n + 1
estados em que, s transies existentes se acrescenta uma transio por c de cada
estado final para o novo estado, passando este a ser o nico estado final, pelo que nos
restringiremos ao caso de apenas um estado final.
Chamemos GAUC - grafo acclico, til (no sentido de que h apenas um vrtice s tal
que ge(s) = 0 e apenas um vrtice t tal que gs(t) = 0 e qualquer outro vrtice faz
parte de algum caminho de s para ) e completo (no sentido de que existem todos os
arcos possveis).
Proposio 4.5.1 Num GAUC de n vrtices o nmero de caminhos de s para t

2n-2
Demonstrao: Vamos provar a proposio por induo no nmero de vrtices do

GAUC. O caso base o caso em que n = 2 e neste caso trivial verificar que h apenas
um caminho, ou seja, 2 2 - 2 = 1, de s para t. Suponhamos que a proposio verdadeira
para todos os GAUCs com menos de ra+1 vrtices. Seja Gn ( { 1 , . . . , n}, En) o GAUC
de n vrtices em que os vrtices so nomeados de acordo com a nica ordem topolgica.
O GAUC Gn+i de n + 1 vrtices o GAUC em que se adiciona um vrtice n + 1 a Gn
e um arco de cada vrtice de Gn para o vrtice n + 1 sendo este novo vrtice o vrtice
t de Gn+\. Seja NCc{p,q) o nmero de caminhos em G do vrtice p para o vrtice q.
Em Gn+i o nmero de caminhos de s para t ser
68
NCGn+1(l,n+l) = l + YiNCGn(l,i). (4.1)
A parcela 1 na Equao (4.1) devese ao arco (l,n + 1). Vamos mostrar que cada
NCGa(l, i) na Equao (4.1) representa o nmero de caminhos de s para t num CAUC
de % vrtices. Seja Gi = ({1,..., i}, Ei) o subgrafo de G definido pelos vrtices em
{ 1 , . . . , z'} com 2 < i < n. Seja Tn a ordem topolgica em Gn e 77 a ordem topolgica
em Gi. Para todo u { 1 , . . . ,i} temos 7(M) = Tn{u). Em Gj temos = i. Gi um
GAUC de i vrtices pois para quaisquer u, v { 1 , . . . , z} tais que 7(M) < 77(v) temos
(u, v) Ej por Tn{u) < Tn{v) e Gn ser um GA UC. Em G, o nmero de caminhos de
s para exactamente V C G ^ I , i) pois todos os caminhos de s para t em Gj passam
apenas por vrticess u tais que %.(u) < %.(i). Por isto e por G, ser um GA UC com
menos de n + 1 vrtices temos que, usando a hiptese de induo,
NCGn(l,i) = NCGi(s,t) = li-2,
podendo ento reescreverse a Equao (4.1) como
iVG Gn+1 (l,n + l) = l + X:2 i 2 , (4.2)

i=2
ou seja, NCGn+l(l,n + l) = 1 + Si em que Si = 1 + 2 + 4 + 8H h2 i _ 2 com2 <i<n.

Si uma progresso geomtrica com razo 2. A frmula para a soma dos primeiros n
termos de uma progresso geomtrica de razo r [NV90]
Sn = Ux X ,
1r
em que u\ representa o primeiro termo da sucesso, pelo que

1 2n_1
em que o expoente n 1 se deve ao facto de o primeiro termo de Si ser para % 2

e portanto estarmos a considerar de facto os primeiros n 1 termos. Portanto Si
T~l - 1, donde NCGn+1(l,n+ 1) = 1 + 2n~l - 1 = 2"" 1 = 2{-n+^~2, como queramos
mostrar. D
69
Proposio 4.5.2 Dados um autmato A = (Q, S, , q0, F) acclico de n estados com
apenas um estado final e uma expresso regular r, obtida por aplicao do AEE a A,
tem-se que tamanho(r) < k(n 1)2"~ 2 em que k = | S |.
Demonstrao: Para um autmato A acclico de n estados e apenas um estado final,

r ser de tamanho mximo se o grafo subjacente de A for um GAUC de n estados e
r for uma unio das expresses que representam um caminho do estado inicial para o
estado final. Pela Proposio 4.5.1 h exactamente 2n~2 caminhos e portanto r ser
uma unio de 2n~2 expresses em que cada uma destas tem tamanho menor ou igual
a k{n 1). O factor k deve-se ao facto de no AFE associado a A cada transio ser
etiquetada por uma expresso de tamanho menor ou igual a A;. O factor n l deve-se
ao facto de em A o maior caminho ter tamanho menor ou igual a n 1. Neste caso,
D
Pela Proposio 4.5.2 podemos concluir que a funo d e s t r o y S t a t e tem complexidade

0(n3k2n). Iremos agora determinar a complexidade da funo computeBest (ver
Figura 4.5), analisando a complexidade das funes por ela chamadas. A funo
computeWeight tem complexidade 0(n) e executada no mximo n vezes em cada
execuo de computeBest. A funo computeWDist chamada por computeBest no
mximo n vezes e tem complexidade 0(n4) que se deve s seguintes linhas de cdigo:
for i in I n v e r t i c e s [ q ] do
for j in O u t v e r t i c e s [q] do
if j in O u t v e r t i c e s [ i ] then
for k in I n v e r t i c e s [ i ] do
od;
fi;
od;
od;
A funo computeDistGain chamada por computeBest 2 vezes e tem complexidade

0(n3) que se deve s linhas de cdigo seguintes:
70
if ForAll(Invertices[q] , x -> t in Outvertices[x]) then
fi;
od;
em que, para um estado q e para cada estado t e Outvertices[q] se verifica se para

todos os estados x G Invertices[q] se tem t G Outvertices[x]. A funo computeBest
tem, portanto, complexidade 0(nb) que se deve s seguintes linhas de cdigo:
for i in [3..Q] do
AddSetCl, [computeWDist(i)-computeWeight(i) + bonus[i], i ] ) ;
od;
em que Q o nmero de estados do autmato e para cada um

destes estados adicionado, de forma ordenada, lista 1 a lista
[computeWDist(i)-computeWeight(i) + bonus[i], i ] , em que computeWDist(i)
tem complexidade 0(n4). A funo removeImediate tem complexidade 0{n) e
executada no mximo n vezes. Por isto, a heurstica para o caso acclico tem
complexidade 0(n4k2n).
4.6 Concluses
Podemos ver pelas tabelas apresentadas na Seco 4.4 que a heurstica para o caso
acclico produz resultados melhores que os da heurstica para o caso geral, se aplicadas
a autmatos acclicos.
Para terminar, apresentamos um exemplo em que a heurstica para o caso acclico no

consegue produzir a expresso mnima. Consideremos o autmato da Figura 4.10.
71
Figura 4.10: Autmato 663
Considerando neste autmato ini = 1 e fin 2 temos que a nica ordem ptima de
remoo 6,3, 5,4, obtendo-se a expresso r = ((ad+b)f + ae)(hj+i) + ((ad+b)g+c)j
em que tamanho(r) = 15.
Para a escolha do primeiro vrtice a ser removido, a heurstica deste captulo basear-
se-ia nos valores das Tabelas 4.7 e 4.8.
Tabela 4.7: Valores para escolha do primeiro vrtice a ser removido
i WD(i) V(t) bonus [i] WD(i) - V{i) + bonusfi]

3 4 4 0 0
4 3 4 0 -1
5 2 2 0 0
6 2 1 0 1
i dist_gain[i]
6 0
5 0
Assim, o primeiro vrtice a ser removido seria o 6 e o AFE resultante o da Figura

4.11.
72
Figura 4.11: Autmato 663 depois de removido o vrtice 6
Para a escolha do segundo vrtice a ser removido temos os valores das Tabelas 4.9 e
4.10.
Tabela 4.9: Valores para escolha do segundo vrtice a ser removido
i WD(i) 7>(i) bonus [i] WD(i) - V{i) + bonus[i]

3 3 3 0 0
4 5 5 0 0
5 3 2 0 1
Tabela 4.10: dist.gain[i]
i dist_gain[i]
4 2
5 1
O segundo vrtice removido seria portanto o 5 e o AFE resultante o da Figura 4.12.
Figura 4.12: Autmato 663 depois de removidos os vrtices 6 e 5
73
Vemos assim que na escolha do segundo vrtice j h diferena em relao ordem
ptima. Notemos aqui que o estado 5 o nico com valor mximo na ltima coluna da
Tabela 4.9 mas tanto o estado 4 como o 3 seriam elegveis para comparao do valor
de computeDistGain(i). A escolha do estado 4 para figurar na Tabela 4.10 de certo
modo arbitrria, uma vez que feita, em caso de igualdade, pelo ndice maior. Se em
vez do estado 4 tivssemos considerado o estado 3, em vez da Tabela 4.10 teramos a
Tabela 4.11
i dist_gain[i]
3 0
5 1
e neste caso j seria escolhido correctamente (no sentido de corresponder ordem

ptima) o vrtice 3. No entanto, foi tentada uma variao da heurstica que reuniria
neste caso, para comparao do valor de computeDistGain(i), os estados 3, 4 e 5, e
embora, para este autmato, o resultado fosse ptimo, no caso geral obtivemos piores
resultados.
A partir daqui, os vrtices removidos seriam o 4 e depois o 3, obtendo-se a expresso

final s (ad + b)(f(hj + i) + gj) + ae(hj + i) + cj em que tamanho(s) = 16, ou seja,
a expresso obtida tem mais 1 smbolo que a mnima (r = ((ad + b)f + ae)(hj + i) +
((ad + b)g + c)j).
74
Captulo 5
Concluses
Neste captulo comearemos por fazer um resumo do trabalho apresentado e em

seguida um delineamento do trabalho futuro. No Captulo 1 apresentmos as noes
necessrias leitura deste trabalho, bem como a descrio do problema de encontrar, a
partir de um autmato e usando o algortimo da eliminao de estados, uma expresso
regular equivalente com o menor tamanho. Em particular tentmos salientar a
dificuldade do problema, fazendo notar que a ordem de remoo dos estados, na
aplicao do AEE, determina o tamanho da expresso regular obtida.
No Captulo 2 apresentmos uma caracterizao de autmatos acclicos para os quais

pode ser obtida pelo AEE uma expresso regular de tamanho linear no nmero de
transies e em tempo linear tambm no nmero de transies do autmato em causa.
Estes autmatos so aqueles para os quais o seu grafo subjacente no contm como
subgrafo um grafo homeomorfo ao grafo D apresentado na Definio 2.2.3 (ver pgina
26) e para estes autmatos possvel eliminar em cada passo do AEE um estado q com
ge(q) 1 = gs(q) o que garante que a expresso regular obtida ter tamanho igual
ao nmero de transies do autmato inicial. Apresentmos tambm um algoritmo
para determinar se um dado autmato obedece caracterizao apresentada, bem
como uma verso do AEE, que pode ser melhorada, especfica para este tipo de
autmatos. Mostrmos que os autmatos de Thompson de linguagens finitas obedecem
caracterizao apresentada e deixmos em aberto o problema de encontrar, para uma
dada linguagem, um autmato, do tipo caracterizado, que seja mnimo no nmero de
transies.
75
No Captulo 3 apresentmos uma heurstica para o problema de encontrar, a partir de
um autmato e usando o algortimo da eliminao de estados, uma expresso regular
equivalente com o menor tamanho, que foi elaborada no decurso dos trabalhos de
estgio da licenciatura. Esta heurstica baseia-se na noo de peso de um vrtice
apresentada na Seco 3.1 (ver pgina 43) e consiste em eliminar primeiro os estados
com menor peso. De notar que o tamanho da expresso final ser igual soma do peso
do AFE inicial (definido na Seco 3.1) com o peso de cada estado quando removido.
Esta heurstica produz resultados consideravelmente melhores que os produzidos por
uma aplicao do AEE que no tenha em considerao uma escolha adequada do
estado a ser removido em cada passo. Apresentmos tabelas com alguns resultados
obtidos e terminmos com o exemplo de um autmato para o qual a heurstica no
consegue produzir uma expresso de tamanho mnimo obtenvel pelo AEE.
No Captulo 4 apresentmos uma heurstica com o mesmo objectivo que a descrita no

Captulo 3, mas especfica para o caso de autmatos acclicos. Para estes autmatos
tentamos que na expresso final figurem subexpresses da forma a(b + c) ou (a + b)c
em vez de ab + ac ou ac + bc, respectivamente, por uma escolhada adequada da ordem
de remoo dos estados. Dado que nas expresses obtidas a partir de autmatos
acclicos no h a presena do operador * estas simplificaes so as nicas possveis
(exceptuando a + a = a, que no implementmos devido ao custo do teste da incluso
de uma linguagem regular noutra). Apresentmos tabelas que comparam os resultados
obtidos pela heurstica para o caso geral e esta e em que se verifica que os resultados
obtidos pela heurstica especfica so substancialmente melhores. Terminmos o
captulo apresentando o exemplo de um autmato para o qual a heurstica especfica
no consegue produzir uma expresso de tamanho mnimo obtenvel pelo AEE.
Em seguida apresentamos o trabalho que gostaramos de fazer no futuro. Consideremos

a linguagem L(r) em que r = (a + b)*b, sendo tamanho(r) = 3. O AFD mnimo para
esta linguagem encontra-se desenhado na Figura 5.1.
Figura 5.1: Autmato que reconhece L((a + b)*b)
76
Na Tabela 5.1 apresentamos as expresses obtidas pelo AEE para as duas ordens de
remoo possveis.
Tabela 5.1: Expresses obtidas para as duas ordens de remoo possveis
Ordem Expresso Tamanho

1,2 a*b(aa*b + b)* 6
2,1 (bb*a + a)*bb* 6
Como se pode verificar, com nenhuma das ordens foi possvel obter a expresso mnima
r = (a + b)*b. Num autmato til, todas as etiquetas das transies contribuem para o
tamanho da expresso final, no sentido de que nessa expresso as etiquetas aparecero
como subexpresses possivelmente com multiplicidade superior a 1. Isto faz-nos querer
investigar se a Proposio 5.0.1 ser verdadeira.
Proposio 5.0.1 Uma expresso regular mnima para uma dada linguagem L
obtenvel pelo AEE quando aplicado a um AFNDTE que aceite L e seja mnimo no
nmero de transies, se forem feitas, na aplicao do AEE, as simplificaes ae = a
e r + 0 = r.
No artigo [Joh04] apresentado um algoritmo de complexidade 0(2n) para a

minimizao do nmero de transies de um AFNDTE. De acordo com o algoritmo
apresentado neste artigo, o autmato mnimo em transies equivalente ao apresentado
na Figura 5.1 seria o que se encontra na Figura 5.2, onde o smbolo @ representa e.
Figura 5.2: Autmato mnimo em transies que reconhece L((a + b)*b)
Na Tabela 5.2 apresentamos as expresses obtidas pelo AEE para as duas ordens de
remoo possveis, para este autmato mnimo.
77
Tabela 5.2: Expresses obtidas para as duas ordens de remoo possveis
Ordem Expresso Tamanho

1,2 a*b(a*b)* 4
2,1 (a + b)*b 3
Vemos assim que a ordem de remoo 2,1 produz a expresso mnima r = (a + )*6.
Se a Proposio 5.0.1 for verdadeira temos assim um mtodo (ainda que de complexi-
dade exponencial) para calcular uma expresso mnima para uma dada linguagem.
Assumindo que a Proposio 5.0.1 verdadeira e, numa tentativa de reduzir a

complexidade do algoritmo apresentado em [Joh04], temos como objecto de estudo
futuro o Problema 5.0.1.
Problema 5.0.1 (Transio por e que no altera a linguagem reconhecida)
Dados um AFND A (Q, E, S, q0,F) e estados p e q, adicionar ao autmato a transio
(p, e) = q altera a linguagem reconhecida?
78
Referncias
[Aho04] Aho. Computer representation of graphs. In Jonathan L. Gross and Jay

Yellen, editors, Handbook of Graph Theory. CRC Press, 2004.
[ASU86] Alfred V. Aho, Ravi Sethi, and Jeffrey D. Ullman. Compilers Principles,
Techniques, and Tools. Addison Wesley, 1986.
[BJG01] J. Bang-Jensen and G. Gutin. Digraphs: Theory, Algorithms, and

Applications. Monographs in Mathematics (SMM). Springer, 2001.
[CZ00] Pascal Caron and Djelloul Ziadi. Characterization of glushkov automata.

Theoret. Comput. Sci, 233:75-90, 2000.
[DLM04] M. Delgado, S. Linton, and J. Morais. Automata.

A GAP package on automata, version 1.01 2004.
http ://www.gap-system.org/~gap/Packages/automata.html.
[DM04] Manuel Delgado and Jos Morais. Approximation to the smallest

regular expression for a given regular language. In CIAA 2004 - Ninth
International Conference on Implementation and Application of Automata,
Lecture Notes in Computer Science. Springer-Verlag, 2004. poster.
[ESW02] K. Ellul, J. Shallit, and Ming-wei Wang. Regular expressions: New results
and open problems. In Descriptional Complexity of Formal Systems,
Ontario, 2002. http://www.math.uwaterloo.ca/~m2wang/papers/jalc.ps.
[GAP04] The GAP Group. GAP - Groups, Algorithms, and Programming, Version
4-4, 2004. (http://www.gap-system.org).
79
[GJ03] Michael R. Garey and David S. Johnson. Computers and Intractability /
A Guide to the Theory of NP-Completeness. W.H. Freeman &; Company,
New York, 2003.
[GPW98] Dora Giammarresi, Jean-Luc Ponty, and Derick Wood. A re-

examination of the Glushkov and Thompson constructions, 1998.
http://citeseer.ist.psu.edu/giammarresi98reexamination.html.
[GPW99] D. Giammarresi, J. Ponty, and D. Wood. A characterization of Thompson

digraphs, 1999. citeseer.ist.psu.edu/giammarresi99characterization.html.
[Har69] Frank Harary. Graph Theory. Addison-Wesley, 1969.
[HK02] Markus Holzer and Martin Kutrib. Nondeterministic

descriptional complexity of regular languages, September 2002.
http://citeseer.ist.psu.edu/holzer02nondeterministic.html.
[HU01] J. E. Hopcroft and J. D. Ullman. Introduction to Automata Theory,

Languages, and Computation. Addison-Wesley, Reading, MA, USA,
second edition, 2001.
[Joh04] Sebastian John. Minimal unambiguous eNFA. Technical report, Technical

University Berlin, April 2004.
[JR93] Tao Jiang and B. Ravikumar. Minimal NFA problems are hard. SIAM J.
Comput., 22(6):1117-1141, 1993.
[Kle56] S. C. Kleene. Representation of events in nerve nets and finite automata.

In C. E. Shannon and J. McCarthy, editors, Automata Studies, pages 3-41.
Princeton University Press, Princeton, 1956.
[Koz94] Dexter Kozen. A completeness theorem for Kleene algebras and the algebra
of regular events. Infor, and Comput, 110(2):366-390, May 1994.
[KR99] Khuller and Raghavachari. Basic graph algorithms. In Mikhail J. Atallah,

editor, Algorithms and Theory of Computation Handbook. CRC Press,
1999.
[Mit03] Neil Mitchell. Regular expression simplification without finite

state automata. Technical report, University of York, 2003.
80
http://www.nmitchell.co.uk/download/\
regular_expression_simplification.pdf.
[MMP+95] O. Matz, A. Miller, A. Potthoff, W. Thomas, and E. Valkema. Report

on the program AMoRe. Technical Report 9507, Christian Albrechts
Universitt, Kiel, 1995.
[M0066] E. F. Moore. Gedanken experiments on sequential machines. In Automata

Studies. Princeton Univ Press, 1966. pp. 129-153.
[MP43] W. S. McCulloch and W. Pitts. A logical calculus of the ideas immanent

in nervous activity. Bull. Math. Biophysics, 5:115-133, 1943.
[Myh57] J. Myhill. Finite automata and the representation of events. Technical

Report WADD TR-57-624, Wright Patterson AFB, Ohio, 1957. pp. 112-
137.
[Ner58] A. Nerode. Linear automata transformations. In Proceedings of AMS 9,

pages 541-544, 1958.
[NV90] Maria Neves and Maria Vieira. Acesso ao ensino superior: matemtica.
Porto Editora, 1990.
[RS59] M. O. Rabin and D. Scott. Finite automata and their decision problems.
IBM J. Res, 3: 2:115-125, 1959.
[ST99] D. A. Simovici and R. L. Tenney. Theory of formal languages with

applications. World Scientific, 1999.
[TA98] Alejandro A. R. Trejo Ortiz and Guillermo Fernandez Anaya. Regular

expression simplification. Math. Comput. SirnuL, 45(l-2):59-71, 1998.
[Tho68] K. Thompson. Regular expression search algorithm. Commun. ACM,

ll(6):410-422, 1968.
[Wat94a] B. W. Watson. A taxonomy of finite automata minimization algo-

rithms. Technical report, Eindhoven University of Technology, 1994.
citeseer.ist.psu.edu/article/watson94taxonomy.html.
81
[Wat94b] Bruce W. Watson. A taxonomy of finite automata construction al-
gorithms. Technical Report Computing Science Note 93/43, Eind-
hoven University of Technology, The Netherlands, May 1994. cite-
seer.ist.psu.edu/watson94taxonomy.html.
[Yu97] Sheng Yu. Regular languages. In G. Rozenberg and A. Salomaa,

editors, Handbook of Formal Languages, volume 1. Springer-Verlag Berlin
Heidelberg, 1997.
82
ndice de Tabelas
2.1 Contagem de Grafos Nard 27
3.1 Alguns Resultados sem Heurstica 45
3.2 Alguns Resultados com Heurstica 46
3.3 Tamanhos das expresses para alguns Grafos de Cayley 47
3.4 Tamanhos das expresses com a heurstica melhorada 48
3.5 Pesos Iniciais 50
3.6 Pesos no autmato A depois de removido o vrtice 4 50
3.7 Pesos no autmato A depois de removidos os vrtices 4 e 2 51
3.8 Pesos no autmato A depois de removidos os vrtices 4, 2 e 1 51
3.9 Pesos no autmato A depois de removido o vrtice 2 52
3.10 Pesos no autmato A depois de removidos os vrtices 2 e 1 52
3.11 Pesos no autmato A depois de removidos os vrtices 2, 1 e 4 52
3.12 Peso com que cada vrtice foi removido 52
4.1 Valores para escolha do primeiro vrtice a ser removido 63
4.2 dist-gain[i] 63
4.3 Valores para escolha do segundo vrtice a ser removido 63
4.4 dist-gain[i] 64
83
4.5 Heurstica para o caso geral 66
4.6 Heurstica para o caso acclico 66
4.7 Valores para escolha do primeiro vrtice a ser removido 72
4.8 dist-gain[i] 72
4.9 Valores para escolha do segundo vrtice a ser removido 73
4.10 dist-gain[i] 73
4.11 dist-gain[i] 74
5.1 Expresses obtidas para as duas ordens de remoo possveis 77
5.2 Expresses obtidas para as duas ordens de remoo possveis 78
84
ndice de Figuras
1.1 Algoritmo da Eliminao de Estados 16
1.2 Algoritmo de Kleene 19
1.3 Autmato A 20
1.4 Autmato A depois de removido o vrtice 2 20
1.5 Autmato A depois de removidos os vrtices 2 e 1 20
1.6 Autmato A depois de removidos os vrtices 2, 1 e 4 21
1.7 Autmato A depois de removidos os vrtices 2, 1, 4 e 3 21
2.1 Grafo Etiquetado 24
2.2 Autmato no nard 25
2.3 Autmato nard 25
2.4 Grafo D 26
2.5 Autmatos nard de 4 estados 32
2.6 Verifica se um grafo nard 34
85
2.7 NardFAtoRatExp 35
2.8 Autmato de Thompson de 0 36
2.9 Autmato de Thompson de c 36
2.10 Autmato de Thompson de a G E 36
2.11 Autmato de Thompson representando uma unio 36
2.12 Autmato de Thompson representando uma concatenao 37
2.13 Autmato de Thompson representando o fecho de Kleene 37
2.14 Remoo de um vrtice v tal que ge(v) = 1 e gs(v) = 2 38
2.15 Aps a remoo de v 39
2.16 ge(v) = 1 = gs(v) 39
2.17 Aps a remoo de v 39
2.18 Autmato no nard 40
2.19 Autmato nard equivalente 40
3.1 AEE com heurstica para o caso geral 49
3.2 Autmato A 50
4.1 Grafo Etiquetado 56
4.2 Grafo Etiquetado depois de removido q 57
4.3 compute WDist() 59
4.4 computeDistGainQ 60
86
4.5 cornputeBest() 61
4.6 Autmato 847 62
4.7 Autmato 847 depois de removido o estado 5 64
4.8 Autmato 847 depois de removidos os estados 5 e 3 65
4.9 AEE com heurstica para o caso acclico 67
4.10 Autmato 663 72
4.11 Autmato 663 depois de removido o vrtice 6 73
4.12 Autmato 663 depois de removidos os vrtices 6 e 5 73
5.1 Autmato que reconhece L((a + b)*b) 76
5.2 Autmato mnimo em transies que reconhece L((a + b)*b) 77
87
Lista de Acrnimos
AEE, algoritmo da eliminao de estados

AF, autmato finito
AFD, autmato finito determinstico
AFE, autmato finito estendido
AFND, autmato finito no determinstico
AFNDTE, autmato finito no determinstico com transies-e
ge(v), grau de entrada do vrtice v
gs(v), grau de sada do vrtice v
89
ndice Remissivo
adjacncias equivalentes
lista de, 8 autmatos, 13
matriz de, 8 expresses regulares, 6
AEE, 14 Expresses Regulares, 4
AFD, 8
grafo, 7
completo, 9
D, 26
AFE, 11
dirigido, 7
AFND, 10
homeomorfo, 26
AFNDTE, 11
subjacente, 12
alfabeto, 3
grau de entrada, 8
algoritmo
grau de sada, 8
eliminao de estados, 14
GTG, 16
Kleene, 18
arcos, 7 Kleene
arestas, 7 fecho de, 3
autmato
lacete, 7
til, 12
linguagem, 3
acclico, 12
vazia, 3
caminho, 7 linguagens regulares, 3
ciclo, 7
nard, 24
colapsvel, 5
comprimento, 3 ordem topolgica, 8
concatenao, 3
palavra, 3
de linguagens, 3
vazia, 3
configurao, 9
passo de computao, 9
configurao de aceitao, 9
peso
configurao inicial, 9
de um AFE, 43
digrafo, 7 de um vrtice, 43
91
92 NDICE REMISSIVO
tamanho
de uma expresso regular, 6
vrtices
finais, 12
iniciais, 12
intermdios, 12
no teis, 23
I
Apndice A
Cdigo
A.l FAtoRatExpX
FAtoRatExpX := function(A)
local T, # Transition function of the GTG
Q, # The number of states of the GTG without
counting qO and qf
qO, qf, t The two extra states of the GTG
compute GTG,
destroyLoop,
destroyState,
if not IsAutoma tonObj(A) then

ErrorC'The argument to FAtoRatExp must be an automaton");
fi;
T - []; # Transition function of the GTG
Q = A !.states ;
qO = A !.states + 1;
qf A!.states + 2;
## Function that computes the GTG (genera lized transition graph)

## a ssocia ted with the given FA.
computeGTG :" functionO
local list, # List of alphabet symbols
list2,
1,
x,
a, # Alphabet symbol
c, # Counter
p, q; t States
if A!.type = "nondet" then
93
94 PA NDICE A. CDIGO
for p in [ i . . A!.states] do
T[p] : - D :
list :- 0;
c : - 0;
for a in [1 . . A{.alphabet] do
i f q in A! .trans i t ions [a] [p] then
AddClist, a);
c : - c + 1;
fi;
od;
if l i s t = [] then
T[p][q] :" 0; t 0 means the empty_set
elif IsBound(list[2]) then
T[p][q] :-
RatExpOnnLetters(
ShallowCopyCFamilyObj(A)!.alphabet) ,
"union".
List(list, a -> RatExpOnnLettersC
ShallowCopy(FamilyObj (A) ! .alphabet) ,
. [a])));
else
T[p][q] : =
RatExpOnnLetters(
ShallowCopy(FamilyObj(A)!.alphabet),
D , list);
fi;
od;
od;
elif A!.type - "epsilon" then
if IsStringCFamilyObj(A)!.alphabet) then
1 :- ShallowCopyCFamilyObjCA)!.alphabet);
Unbind(l[Length(l)]);
fi;
for p in [1 . . A!.states] do
T[p] := G;
list :- ;
c : - 0;
for a in [1 . . A!.alphabet-1] do
if q in A!.transitions[a][p] then
AddClist, a ) ;
c : c + 1;
fi;
od;
a : A!.alphabet ;
if q in A! .transitions[a] [p] then
AddClist, 0 ) ;
fi;
if l i s t [] then
T[p]Cq] : 0; # 0 means the empty_set
e l i f IsBoundClist[2]) then
A.l. FATORATEX
P X
list2 : Di
for x in list do
if x 0 then
if IsStringCFamilyObj(A) ! .alphabet) then
Add(list2, RatExpOnnLettersCl, [], D ) ) ;
else
Add(list2, RatExpOnnLettersC
FamilyObjCA)!.alphabet-1, , []));
fi;
else
1, [], W ) ) ;
else
FamilyObj (A) ! . alphabet-1, D , [x] ) ) ;
fi;
fi;
od;
T[p][q] : RatExpOnnLettersC
1, "union", list2);
else
FamilyObj CA)!.alphabet-1,
"union", list2);
fi;
else
if list = [0] then
if IsStringCFamilyObjCA)!.alphabet) then
T[p][q] := RatExpOnnLettersCl, , []);
else
FamilyObj CA)!, alphabet-1, D , D ) ;
fi;
else
if IsStringCFamilyObjCA)!.alphabet) then
1, G , list);
else
T[p][q] := RatExpOnnLettersC
FamilyObj CA) ! .alphabet-1, D , l i s t ) ;
fi;
fi;
fi;
od;
od;
else
for p in [1 . . A{.states] do
T[p] :- 0 ;
for q in [1 . . A!.states] do
l i s t :- [ ] ;
APNDICE A. CDIGO
c :- 0;
for a in [1 .. A !.alphabet] do
# The only difference to the
nondeterministic case
if q A!.transitions[a][p] then
Adddist, a);
c := c + 1;
fi;
od;
if list [] then
T[p3 [q] : 0; # 0 means the empty_set
e l i f IsBounddist [2] ) then
T[p][q] := RatExpQnnLettersC
ShallowCopyCFamilyObj(A)!.alphabet),
"union", List(
l i s t , a -> RatExpOniiLetters (
0. [a])));
else
T[p] [q] := RatExpQnnLettersC
D , list);
fi;
od;
od;
fi;
T[q0] :- D ; T[qf] :- [] ;
T[p][q0] :- 0;
if p in A!.accepting then
if A!.type = "epsilon" then
if IsString(FamilyObj(A)!.alphabet) then
T[p][qf] :- RatExpOnnLettersd, D . G ) ;
else
T[p][qf] := RatExpOnnLetters(
FamilyObj(A)!.alphabet-l, Q, [ ] ) ;
fi;
else
T[p][qf] := RatExpOnnLetters(
ShallowCopy(FamilyObj(A)!.alphabet), [ ] , []);
fi;
else
TCp] [qf] := 0;
fi;
od;
if q in A ! . i n i t i a l then
if A!-type * "epsilon" then
T[q0][q] := RatExpOnnLettersd, , D ) ;
else
T[q0] [q] := RatExpQnnLettersC
A J. FATORATEXP X
FamilyObj (A)!, alphabet-1, [], []);

fi;
else
T[qO][q] :- RatExpOnnLetters(
ShallowCopy(FamilyObj(A)!.alphabet), [ ] , []);
fi;
else
T[qO][q] :- 0;
fi;
T[qf][q] :- 0;
od;
T[q0][q0] :- 0; T[q0] [qf] :- 0; T[qf ] [qO] := 0; T[qf] [qf] := 0;
end;
## End of computeGTGO
# Function that deletes a loop in the GTG

destroyLoop : function(n)
local q;
if not T[n][n] 0 then

for q in [1 .. n-1] do
if T[n] [q] - 0 then
e l i f T [ n ] [ q ] ! . l i s t . e x p - then
T [n] [q] : - StarRatExp(T [n] [n] ) ;
else
T[n][q] :- ProductRatExp(
StarRatExp (T [n] [n] ) , T [n] [q] ) ;
fi;
od;
for q in [n+1 . . Q+2] do
if T[n] [q] - 0 then
e l i f T[n] [q] ! . l i s t . e x p - D then
T[n][q] :- StarRatExp(T[n] [n]) ;
else
T[n][q] :- ProductRatExp(
StarRatExp (T [n] [n] ) , T [n] [q] ) ;
fi;
od;
T[n][n] := 0;
fi;
end;
## End of destroyLoop()
## Function that deletes a state in the GTG

destroyState : function(n)
local p, q;
for p in [1 . . n-1] do
if not T[p][n] 0 then
for q in [1 . . n-1] do
98 APNDICE A. CDIGO
if not T [n] [q] - 0 then

if T [p] [q] - 0 then
T [p] [q] : - ProductRatExp(T [p] [n] , T [n] [q] ) ;
else
T[p][q] := UnionRatExp(
ProductRatExp(T[p][n], T[n][q]), T[p][q]);
fi;
fi;
od;
if not T[n][q] 0 then
if T[p][q] - 0 then
T[p][q] :- ProductRatExp(T[p][n], T[n][q]);
else
T[p][q] : UnionRatExp(
fi;
fi;
od;
fi;
od;
for p in [n+1 . . Q+2] do
if not T[p][n] * 0 then
for q in [1 . . n-1] do
if not T[n][q] - 0 then
if T[p][q] 0 then
T[p][q] := ProductRatExp(T[p][n], T[n][q]);
else
T[p][q] : UnionRatExpC
fi;
fi;
od;
if not T[n][q] - 0 then
if T[p][q] - 0 then
T [p] [q] : - ProductRatExp (T [p] [n] , T [n] [q] ) ;
else
T[p][q] :- UnionRatExp(
fi;
fi;
od;
fi;
od;
for p in [1 . . n-1] do
for q in [n . . Q+l] do
T[p][q] :- T[p][q+1];
od;
od;
for p in [n . . Q+l] do
T[p] :- T[p+1];
A.2. NARDFATORATEXP
f o r q i n [n . . Q+l] do
T[p][q] : - T[p] [ q + l ] ;
od;
od;
Q : Q - li
end;
## End of d e s t r o y S t a t e O
computeGTGO ;
w h i l e Q > 0 do
destroyLoop(Q);
destroyState(Q);
od;
i f T [ l ] [2] - 0 then
return(RatExpOnnLetters(A!.alphabet, [ ] , "empty_set"));
else
retura(T[1] [ 2 ] ) ;
fi;
end:
A.2 NardFAtoRatExp
NardFAtoRatExp := function(A)
WT, # Weighted transition function of the GTG
Nout, * Number of edges going out to distinct vertices
Nin, * Number of edges coming in from distinct
vertices
Invertices, # The numbers of the vertices that have a
transition into i
Outvertices, t The numbers of the vertices that have a
transition from i
Q, # The number of states of the GTG without
counting qO and qf
qO, qf, # The two extra states of the GTG
best,
computeGTG,
destroyState,
flag,
perm,
i. j. k, q i. P;
if not IsAutomatonO bj(A) then

ErrorC'The argument to NardFAtoRatExp must be an automaton");
fi;
perm : [ 1 . . A ! . s t a t e s ] ;
100 APNDICE A. CDIGO
i :- A!. i n i t i a l [ l ] ;
j :- A!.accepting[1];
perm[i] : 1;
perm[l] : i;
p : Position(perm, 2 ) ;
k : perm[j] ;
perm[j] := 2;
perm[p] : k;
A :" PennutedAutomaton(A, perm);
T :- D ; * Transition function of the GTG

WT :- D ;
Nout : D ;
Nin : D;
Q : A!.states;
qO : A!.States + 1;
qf : A!.states + 2;
for i in [1 .. qf] do
Nin[i] := 0;
od;
NoutCqO] := 0; # Value not used but saves tests
Nout[qf] : 0; # Value not used but saves tests
Invertices : D ;
Outvertices : D ;
for i in [i .. Q+2] do
Invertices [i] : [3;
Outvertices[i] := [];
od;
## Function that computes the GTG (generalized transition graph)

#t associated with the given FA.
computeGTG := functionO
local list, # List of alphabet symbols
list2,
.
a, # Alphabet symbol
C, # Counter
p, q; * States
if A!.type "nondet" then

for p in [1 .. A!.states] do
T[p] :- [];
WT[p] :- D ;
Nout[p] :- 0;
for q in [1 .. A!.states] do
list :- ;
c :- 0;
for a in [1 .. A!.alphabet] do
Add(list, a ) ;
c : c + 1;
if not q p then
A.2. NARDFATORATEX
P
AddSet(Invertices[q], p) ;
AddSet(Outvert i c e s [ p ] , q) ;
fi;
fi;
odj
if l i s t [] then
T[p][q] i* 0; # 0 means the empty_set
WT[p][q] :- - 1 ;
e l i f IsBound(list[2]) then
T[p][q] : RatExpOnnLetters(
ShallowCopy(FamilyObj(A)!.alphabet), "union"
L i s t ( l i s t , a -> RatExpOnnLetters(
ShallowCopy(FamilyObj(A)!.alphabet),
, [a])));
WT[P:|[q] :- c;
if not p = q then
Nout[p] :- N outCp] + 1;
NinCq] :- N in[q] + 1;
fi;
else
T[p][q] :- RatExpOnnLetters(
ShallowCopy(FamilyObj(A)!.alphabet), [], list)
WT[p] [q] :- c;
if not p = q then
Nout[p] :- N out[p] + 1;
Hin[q] :- N in[q] + 1;
fi:
li;
od;
od;
elif A!.type - "epsilon" then
1 :- ShallowCopy(FamilyObj(A)!.alphabet);
Onbindd [Length(l)] ) ;
fi;
T[p] :- D ;
WT[p] :- ;
NoutCp] :- 0;
l i s t : [ ] ;
c := 0;
for a in [1 . . A!.alphabet-!] do
Adddist, a);
c :- c + 1;
if not q = p then
AddSet(Invertices[q], p);
AddSet(Outvertices[p], q) ;
fi;
fi;
od;
APNDICE A. CDIGO
a : A!.alphabet ;
Add(list, 0);
if not q p then
AddSet(Invertices [q], p) ;
AddSetCOutvertices[p], q) ;
fi;
fi!
if list [] then
T[p][q] : 0; # 0 means the empty_set
HT[p][q] := - i ;
e l i f IsBound(list[2]) then
l i s t 2 :- D ;
for x in l i s t do
i f i 0 then
Add(list2, RatExpOnnLettersCl, [ ] , [ ] ) ) ;
else
FamilyQbj(A)!.alphabet-l, [ ] , D ) ) ;
fi;
else
1. [], W));
else
Add(list2, RatExpOnnLetters(
FarailyObj(A)!.alphabet-1, [] , [ x ] ) ) ;
fi;
fi;
od;
T[p][q] := RatExpOnnLettersC
1, "union", list2);
else
FamilyObj(A)!.alphabet-1, "union", list2);
fi;
WT[p][q] :- c;
if not p q then
Nout[p] := N out[p] + 1;
Nin[q] := N in[q] + 1;
fi;
else
if l i s t [0] then
T[p][q] : RatExpOnnLettersCl, , [ ] ) ;
else
FamilyObj CA) ! . alphabet-1, [] , [] ) ;
fi;
else
A.2. NARDFATORATEX
P
i f IsString(Familybj(A)!.alphabet) then
T[p][q] : - RatExpOnnLetters(l, [], list);
else
T[p][q] := RatExpOnnLetters(
FamilyObj(A)! . a l p h a b e t - 1 , D. list);
fi;
fi;
WT[p][q] := c;
i f not p * q then
Nout[p] : - N out[p] + 1;
NinCq] : - N in[q] + 1;
i;
fi;
od;
od;
else
for p in [1 .. A!.states] do
T[p] : D ;
WT[p] :- 0;
Nout[p] := 0;
for q in [1 .. A!.states] do
list := [];
c :- 0;
for a in [1 .. A !.alphabet] do
# The only difference to the nondeterministic case
if q - A!.transitions[a][p] then
AddClist, a ) ;
C : c + 1;
s
if not q p then
AddSet(Invertices[q], p ) ;
AddSet(Outvertices[p], q) ;
fi;
fi;
od;
if list [] then
T[p] [q] : 0; # 0 means the empty_set
WT[p][q] : - - 1 ;
elif IsBound(list[2]) then
T[p][q] : - RatExpOnnLetters(ShallowCopy(
FamilyObj(A)!.alphabet), "union",
List(list, a -> RatExpOnnLetters(
ShallowCopy (FamilyObj (A) ( . a l p h a b e t ) , , [a])));
HT[p][q] : - c;
i f not p q then
Hout[p] := N outCp] + 1;
Nin[q] : - N in[q] + 1;
fi;
else
Tip][q] : - RatExpOnnLetters(ShallowCopy(
FamilyObj (A)! . a l p h a b e t ) , D, list);
WT[p][q] : - c;
B
i f not p q then
Nout[p] := Nout[p] + i;
Nin[q] : = Nin[q] + 1;
fi;
fi;
od;
od;
fi;
T[q0] :- D ; T[qf] := [] ;
WT[qO] := ; WT[qf] :- ;
T[p] [qO] :- 0;
WTCpHqO] :- - 1 ;
if p in A!.accepting then
T[p][qf] := RatExpOnnLetters(1, [], ) ;
else
T[p][qf] :- RatExpOnnLetters(
FamilyObj(A)!.alphabet-1, [] , G ) ;
fi;
else
T[p][qf] :- RatExpOnnLetters(ShallowCopy(
FamilyObj(A)!.alphabet), [ ] , ) ;
fi;
WT[p][qf] :- 0;
Nout[p] :- Hout[p] + 1;
AddSet(Invertices[qf], p) ;
AddSet(Ontvertices[p], qf ) ;
else
T[p][qf] :- 0;
WT[p][qf] :- - 1 ;
fi;
od;
if q in A ! . i n i t i a l then
T[q0][q] :- RatExpOnnLetters(1, 0 , 0 ) ;
else
T[qO][q] : RatExpOnnLetters (
FamilyObj (A)!.alphabet-1, G , G ) ;
fi;
else
T[qO][q] :- RatExpOnnLetters(ShallowCopy(
FamilyObj (A)!, alphabet), G . G ) ;
fi;
WT[qO][q] :- 0;
Nin[q] := Nin[q] + 1;
AddSet(Invertices[q], qO);
AddSet(Outvertices[qO], q) ;
else
T[qO][q] :- 0;
A.2. NARDFATORATEXP
WT[qO][q] : - - 1 ;
fi;
T[qf] [q] : - 0 :
WT[qf][q] := - 1 ;
od;
T[qO][qO] : - 0; T[q0] [qf] : - 0; T[qf] [qO] : - 0; T[qf] [qf] : - 0;
WT[qO][qO] : - - 1 ; WT[qO][qf] := - 1 ; WT[qi][qO] := - 1 ;
WT[qf][qf] := - 1 ;
end;
## End of computeGTGQ
## Function t h a t d e l e t e s a s t a t e i n the GTG

destroyState : f u n c t i o n ( n )
l o c a l p, q;
f o r p i n I n v e r t i c e s [ n ] do
f o r q i n O u t v e r t i c e s [ n ] do
i f T [ p ] [ q ] 0 then
T[p][q] := ProductRatExp(T[p][n], T[n][q]);
WT[p][q] : - WT[p][n] + WT[n] [q] ;
else
T[p] [q] : UnionRatExp(ProductRatExp(T[p][n],
T[n][q]), T[p][q]);
i f WT[p][q] = 0 then
WT[p][q] : - WT[p][n] + WT[n][q] + 1;
else
WT[p][q] : - WT[p][n] + WT[n][q] + WT [p] [q] ;
fi;
fi;
od;
od;
f o r p i n [1 . . n-1] do
T[p][q] : - TCp] [ q + l ] ;
WT[p][q] := WT[p][q+l];
od;
od;
f o r p i n [n . . Q+l] do
T[p] : - T[p+1];
WT[p] : - WT[p+l];
T[p][q] :- T[p][q+1];
WT[p][q] : - WT[p][q+l];
od;
od;
Q := Q - l;
f o r p i n [1 . . Q+2] do
Nout[p] : - 0; N in[p] := 0;
Invertices[p] := D ; 0utvertices[p] := [] ;
od;
f o r p i n [1 . . Q+2] do
for q in [1 .. p-1] do
if WT[p][q] >- 0 then
Nout[p] :- Nout[p] + 1;
Nin[q] := Nin[q] + 1;
AddSet(Invertices[q], p ) ;
AddSet(Outvertices[p], q) j
fii
od;
foi q in [p+1 .. Q+2] do
if WT[p][q] >- 0 then
Nout[p] :- Nout[p] + 1;
Nin[q] := Nin[q] + 1;
AddSet(Invertices[q], p);
AddSet(Outvert ices[p] . q ) ;
fi;
od;
od;
end
## End of destroyState()
#
# Main
#--
computeGTGO ;
while Q > 0 do
for i in [3..Q] do
if N in[i] - 0 or N out[i] 0 or
(Nin[i] - 1 and N out[i] " 1) then
destroyState(i);
break;
fi;
od;
od;
if T[l][2] - 0 then
if A!.type * "epsilon" then
r := RatExpOnnLettersd, [] , "empty_set") ;
else
r := RatExpOnnLetters(
ShallowCopy(FamilyObj(A)!.alphabet), [ ] , "empty_set");
fi;
Setter(SizeRatExp)(r,0);
MinimalKnovnRatExp(A)[1] : r;
return(r);
else
r :- T [ l ] [ 2 ] ;
if WT[1] [2] = 0 then
Setter(SizeRatExp)(r,l);
else
A.3. FATORATEX
P
Setter(SizeRatExp)(r,WT[1][2]);
fi;
retum(r);
fi;
end;
A.3 FAtoRatExp
FAtoRatExp : function(A)
Nout, # Number of edges going out to distinct vertices
Bin, # Number of edges coming in from distinct
vertices
Invertices, # The numbers of the vertices that have a
transition into i
Outvertices, # The numbers of the vertices that have a
transition from i
Inv,
Outv,
Q. The number of states of the GTG without
counting qO and qf
qO, qf, The two extra states of the GTG
WL,
V,
computeGTG,
destroyLoop,
destroyState,
computeWeight,
computeBest, # Try to choose the best vertex
flag,
i, q, r, 1;
if not IsAutomatonO bj(A) then

ErrorC'The argument to FAtoRatExp must be an automaton");
fi;
T = t Transition function of the GTG
WT =
WL -D
Nout :- D
Nin := G ;
Q A!.states;
qO = A!.states + 1;
- A!.states + 2;
qf
for i in [1 . . qf 3 do
Nin[i] :- 0;
od;
Nout[q0] :- 0 # Value not used but saves tests
Nout[qf] : 0 # Value not used but saves tests
Invertices : ;
Outvertices :- [];
for i in [1 .. Q+2] do
Invertices [i] : [] ;
Outvertices[i] := [];
od;

## associated with the given FA.
computeGTG : functionO
... Cdigo igual ao da funo NardFAtoRatExp ...
end;
## End of computeGTG()
## Function that deletes a loop in the GTG

destroyLoop : function(n)
end;
## End of destroyLoopO

destroyState :- function(n)
. .. Cdigo igual ao da funo NardFAtoRatExp .. .
end;
#* End of destroyStateO
computeWeight : = function(i)
local v, p, q;
v : - 0;
for p in Invertices[i] do
v . v + WT[p][i] * (N out[i] - 1);
od;
if WT[i][i] = -1 then # Do nothing, there i s no loop
else
v : - w + HT[i][i] * (N out[i] * N in[i] - 1);
fi;
for q in Outvertices[i] do
v : - v + WT[i][q] * (N in[i] - 1);
od;
return(w);
end;
## End of computeWeight()
local p, q, i, v;
A.3. FATORATEXP
if WL [] then
for i in [1 .. t|] do
AddSet(WL, [computeWeightii), i] ) ;
od;
else
for i in Inv do
AddSet(WL, [computeWeight(i),i]);
od;
for i in Outv do
AddSet(WL, [eomputeWeight(i),i]);
od;
fi;
retum(WL[l][2]);
end;
## End of computeBestO
computeGTGO ;
flag := t r u e ;
w h i l e f l a g do
f l a g : f a l s e ;
f o r i i n [1 . . Q] do
i f N o u t [ i ] 0 then
destroyLoop(i);
destroyState(i);
flag := t r u e ;
break;
fi;
od;
od;
flag := t r u e ;
w h i l e f l a g do
f l a g : f a l s e ;
f o r i i n [1 . . Q] do
i f N i n [ i ] 0 then
destroyLoop(i) ;
destroyState(i);
flag := t r u e ;
break;
fi;
od;
od;
w h i l e Q > 0 do
V : computeBestO;
i : - 1;
w h i l e IsBound(WL[i]) do
i f WL[i][2] - V then
Unbind(WL[i;i);
e l i f WL[i][2] > V then
i f WL[i][2] i n I n v e r t i c e s [V] or
WL[i][2] i n Q u t v e r t i c e s [ V ]
Unbind(WL[i]);
else
WL[i][2] : - WL[i][2] - 1;
fii
else
if WL[i][2] in Invertices[V] or
WL[i][2] in Outvertices then
Unbind(WL[i]);
fi;
fi;
i := i + 1;
od;
WL : C ompacted(WL);
Inv : - Difference(Invertices[V] , [Q+l.Q+2]);
Outv := Difference(Outvertices[V], [0+1,0+2]);
i := i ;
while IsBound(Inv[i]) do
if Inv[i] > V then
Inv[i] : Inv[i] - 1;
fi;
i : - i + 1;
od;
i : - 1;
while IsBound(0utv[i]) do
if 0utv[i] > V then
0utv[i] : 0utv[i] - 1;
fi;
i : - i + 1;
od;
destroyLoop(V);
destroyState(V);
od;
if T[i] [2] - 0 then

r := RatExpOnnLettersd, [], "empty_set");
else
r :* RatExpOnnLetters(ShallowCopy(
FamilyObj (A) ! . alphabet) , [] , "ei _set");
fi;
retnrn(r);
else
r :- T[l][2];
if WT[i] [2] = 0 then
else
Setter(SizeRatExp)(r,WT[l][2]);
fi;
return(r);
fi;
end;
A.4. ACYCLICFATORATEXP
A.4 AcyclicFAtoRatExp
AcyclicFAtoRatExp function(A)
Nout, 4 Number of edges going out to distinct vertices
Min, # Number of edges coming in from distinct
vertices
Invert ices, # The numbers of the vertices that have a
transition into i
Outvertices, # The numbers of the vertices that have a
transition from i
Q. # The number of states of the GTG without
counting qO and qf
qO, qf, t The two extra states of the GTG
best,
computeGTG,
destroyState,
computeWeight,
computeHDist,
computeDistGain, dist.gain,
computeBest, # Try to choose the best vertex
removelmediate,
flag,
perm, bonus,
i, j, k, q, r, 1, p;
if not IsAutomatonObj(A) then

ErrorC'The argument to AcyclicFAtoRatExp must be an automaton");
fi;
perm :m [1..A!.states];
i : A!.initial[l];
j := A ! . a c c e p t i n g [ l ] ;
perm[i] : 1;
perm[l] :- i;
p : Positionnera, 2);
k : perm[j] ;
perm[j] : - 2 ;
perm[p] :~ k;
A :- PermutedAutomaton(A, perm);
T := []; # Transition function of the GTG

WT :- [];
Nout :- G
Nin := D ;
Q A!.states;
qO A!.states + 1;
qf A !.states + 2 ;
for i in [1 qf] do
Nin[i] :
od;
Nout[qO] : 0; # Value not used but saves tests
Nout[qf] : 0; * Value not used but saves tests
Invertices : D ;
Outvertices : D ;
for i in [1 . . Q+2] do
Invertices [i] : [] ;
Outvertices[i] :- [];
od;

## associated vith the given FA.
computeGTG : functionO
end;
## End of computeGTGO ~

destroyState : function(n)
end;
## End of destroyStateO
computeWeight :- function(i)
... Cdigo igual ao da funo FAtoRatExp ...
end;
## End of computeWeight()
computeWDist :* function(q)
local i, j, k, v;
w :- 0;
for i in Invertices[q] do
for j in Outvertices[q] do
if j in Outvertices[i] then
if Nout[j] 1 and Nin[j] - 2 and Nin[q] = 1 then
bonus[q] := bonus[q] + computeWeight(j);
fi;
if Nout[i] - 2 and Nin[i] = i and Nout[q] = 1 then
bonus[q] := bonus[q] + computeWeight(i);
fi;
for k in Invertices[i] do
w :- v + WT[k][i];
od;
for k in Outvertices[j] do
V :- + WT[j][k];
od;
fi;
A.4. ACYCLICFATORATEX
P 113
od;
od;
return(w);
end;
## End of contputeWDistO
computeDistGain : function(q)
local s, t;
dist_gain :- L i s t ( [ l . . Q ] , x->0);
if ForAll(Invertices[q], x -> t in Outvertices[x]) then
dist_gain[t] := dist_gain[t] + N out[t];
fi;
od;
for s in Invertices[q] do
if ForAll(Outvertices[q], x -> s in Invertices[x]) then
dist_gain[s] : dist_gain[s] + N in[s];
fi;
od;
end;
## End of computeDistGainO
local i , j , 1, s, t , dg;
if Q = 2 then
return(l);
fi;
bonus := L i s t ( [ l . . Q ] , x->0);
1 :- ;
j :- 0;
for i in [3..Q] do
AddSet(l, [computeWDist(i)~computeWeight(i) + bonus[i] t i ] ) ;
J i- j + i:
od;
if j > 1 then
s : l [ j - l ] [ 2 ] ;
t := l [ j ] [ 2 ] ;
computeDistGain(s);
dg :~ StructuralCopy(dist_gain);
coraputeDistGain(t);
if dg[t] > dist_gain[s] then
return(s);
else
return(t);
fi;
else
return(l[j][2]);
fi;
end;
## End of computeBestO
removeImediate : functionO
local i , f l a g ;
flag : f a l s e ;
for i in [3..Q] do
if Nin[i] 0 or Nout[i] 0 or
(Nin[i] 1 and Hout[i] 1) then
flag :< t r u e ;
destroyState(i);
break;
fi;
od;
if flag then
removelmediateO ;
fi;
end;
## End of removelmediateO
*
# Main Code
#
computeGTGO ;
removelmediateO ;
while Q > 2 do
q := computeBestO;
destroyState(q) ;
removelmediateO ;
od;
for i in [i.. Q] do
destroyState(l) ;
od;
if T[i] [2] - 0 then

if A!.type "epsilon" then
r := RatExpOnnLettersO, [] , "empty_set") ;
else
r := RatExpOnnLetters(
ShallowCopy(FamilyObj(A)!.alphabet), D . "empty_set");
fi;
Setter(SizeRatExpKr ,0) ;
MinimalKnounRatExp(A) [1] := r ;
return(r);
else
r :- T[l][2];
if WT[1] [2] = 0 then
A.4. ACYCLICFATORATEXP 115
Setter(SizeRatExp)(r,l);
else
Setter(SizeRatExp)(r,WT[1][2]);
fi;
return(r);
fi;
end;

5337 TM 01 P

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

5337 TM 01 P

Enviado por

Direitos autorais:

Formatos disponíveis

Jos Joo Gonalves Morais

Obteno de expresses regulares

Departamento de Cincia de Computadores

Obteno de expresses regulares

Tese submetida Faculdade de Cincias da

Departamento de Cincia de Computadores

O problema que nos propomos tratar neste trabalho o de obter, a partir de um

Neste trabalho apresentamos um resultado que caracteriza um tipo de autmatos para

1.1 Definies Fundamentais 3

1.1.1 Expresses Regulares 4

1.1.1.1 Medidas de Complexidade de Expresses Regulares . . 5

1.1.1.2 Equivalncia de Expresses Regulares 6

1.1.2 Algumas Noes Elementares da Teoria de Grafos 7

1.1.3 Autmatos Finitos 8

1.1.3.1 Autmatos Finitos Determinsticos 8

1.1.3.2 Autmatos Finitos no Determinsticos 10

1.1.3.3 Autmatos Finitos no Determinsticos com

1.1.3.4 Autmatos Finitos Estendidos 11

1.1.4 Autmatos e Grafos 12

1.1.5 Equivalncia dos Modelos Apresentados 13

1.1.6 Autmatos Mnimos 14

1.1.7 Algoritmo da Eliminao de Estados 14

1.1.8 Algoritmo de Kleene 18

1.2 Descrio do Problema 18

2.2 Autmatos nard 24

2.4 Autmatos de Thompson 35

3 Uma heurstica para o caso geral 43

3.3 Alguns Resultados Experimentais 45

4 Uma heurstica para o caso acclico 55

4.4 Alguns Resultados Experimentais 65

A.3 FAtoRatExp 107

A.4 AcyclicFAtoRatExp 111

A teoria de linguagens formais uma rea fundamental da cincia de computadores.

As linguagens regulares e os autmatos finitos tm uma grande variedade de aplicaes,

Na seco seguinte apresentaremos as definies necessrias leitura deste trabalho.

1.1 Definies Fundamentais

Apresentamos em seguida as definies fundamentais para a leitura deste trabalho.

Chamamos alfabeto a um conjunto finito e no vazio de smbolos. Uma palavra sobre

A concatenao de duas palavras a palavra formada pela justaposio das duas,

A potncia wn de uma palavra indutivamente definida por: w = e A wn+1 = wnw.

Denotamos por E* o conjunto de todas as palavras sobre o alfabeto E. O comprimento

Uma linguagem L sobre E um conjunto de palavras sobre E. A linguagem vazia

Dada uma linguagem L definemse indutivamente as suas potncias por: L =

O conjunto das linguagens regulares sobre um alfabeto E definido como o menor

a linguagem {e}, constituda pela palavra vazia, uma linguagem regular,

para cada a S, a linguagem {a} uma linguagem regular,

se Li e L2 so linguagens regulares, ento Li U L2, Li L 2 e L\ so linguagens

1.1.1 Expresses Regulares

Expresses regulares so uma forma sequencial de especificar uma linguagem regular

Definimos indutivamente uma expresso regular r sobre um alfabeto E e a linguagem

1. r = 0 uma expresso regular e denota a linguagem L(r) = 0.

2. r e uma expresso regular e denota a linguagem L(r) = {e}.

3. r a com a e E uma expresso regular e denota a linguagem L(r) = {a}.

Sejam T\ e r 2 duas expresses regulares, ento

4. r (ri + r 2 ) uma expresso regular e denota a linguagem L(r) = L ( r i ) u L ( r 2 ) .

5. r = (ri r 2 ) uma expresso regular e denota a linguagem L{r) = L(ri)L(r 2 ).

6. r = r* uma expresso regular e denota a linguagem L(r) = (L(ri))*.

Na literatura h vrias medidas de complexidade de uma expresso regular:

1. comprimento: o nmero total de smbolos, incluindo parntesis e operadores,

2. comprimento da expresso convertida para notao polaca (sem parntesis) e

3. o nmero total de ocorrncias de smbolos do alfabeto na expresso.

Uma expresso regular r diz-se colapsvel [ESW02] se e s se:

1. r contm o smbolo 0 e o nmero de smbolos em r for superior a 1 ou

13. e + rr < r