UNIVERSIDADE DO VALE DO ITAJAÍ
PAULO ROBERTO LIMA
UM SOFTWARE EDUCACIONAL PARA CONSTRUÇÃO E VALIDAÇÃO DE FORMALISMOS UTILIZADOS NA GERAÇÃO
E RECONHECIMENTO DE SENTENÇAS DE UMA LINGUAGEM REGULAR
São José 2006
2
PAULO ROBERTO LIMA
UM SOFTWARE EDUCACIONAL PARA CONSTRUÇÃO E VALIDAÇÃO DE FORMALISMOS UTILIZADOS NA GERAÇÃO
E RECONHECIMENTO DE SENTENÇAS DE UMA LINGUAGEM REGULAR
Trabalho elaborado para obtenção de conceito na disciplina Trabalho de Conclusão de Curso, do curso de Bacharelado em Ciência da Computação da UNIVALI – São José.
PROF. M.ENG. ALESSANDRO MUELLER
São José 2006
3
PAULO ROBERTO LIMA
UM SOFTWARE EDUCACIONAL PARA CONSTRUÇÃO E VALIDAÇÃO DE FORMALISMOS UTILIZADOS NA GERAÇÃO E
RECONHECIMENTO DE SENTENÇAS DE UMA LINGUAGEM REGULAR
Este Trabalho de Conclusão de Curso foi julgado adequado para obtenção do título de Bacharel
em Ciência da Computação e aprovado pelo Curso de Ciência da Computação, da Universidade
do Vale do Itajaí (SC), Centro de Educação São José.
São José, 14 de dezembro de 2006.
Apresentada à Banca Examinadora formada pelos professores:
Prof. M.Eng. Alessandro Mueller Orientador
Prof. Msc. Paulo Roberto Riccioni Gonçalves, membro da banca examinadora.
Prof. Esp. Marlise There Dias, membro da banca examinadora.
4
AGRADECIMENTOS
Agradeço a Deus pelo dom da vida e por estar sempre presente ao longo deste caminho e de
minha vida.
Aos meus pais, Paulo e Gislaine, por todo amor e carinho, pelas palavras de conforto nas horas de
dificuldade e pelo incentivo sempre dado, por tudo o que abriram mão na vida para hoje eu estar
aqui. Amo vocês.
A minha amada Ana Paula, por estar sempre ao meu lado apoiando ou criticando, por ter mudado
tanto minha vida quando nela entrou, por ser uma grande companheira. Hoje posso dizer que sou
uma pessoa bem melhor e devo isto a você. Te amo muito. Sempre.
A minhas irmãs Michele e Monique, por estarem sempre tentando ajudar de alguma maneira, e
agora longe continuam tentando. Saudades.
À minha grande amiga Josiane, a quem devo muito esse trabalho. Não sei como te agradecer.
Por fim a todos os amigos que de alguma forma contribuíram para conclusão deste trabalho.
5
Nosso medo mais profundo não é sermos incapazes.
Nosso medo mais profundo é termos poder demais.
É nossa luz, não nossa escuridão que mais nos assusta.
Jogar pouco não agrada ao mundo.
Não há nada de luminoso em se diminuir para que outras
pessoas não se sintam inseguras à sua volta.
Fomos todos feitos para brilhar como as crianças.
Não está só em alguns de nós, está em todos.
E ao deixarmos nossa própria luz brilhar
inconscientemente permitimos que outros façam o mesmo.
Já que nos livramos de nosso próprio medo
nossa presença automaticamente liberta outros.
(Autor Desconhecido)
6
RESUMO
A Teoria de Linguagens Formais disponibiliza um conjunto de formalismos que podem ser
utilizados para especificação e reconhecimento de sentenças de uma linguagem de programação.
Os Autômatos Finitos são formalismos usualmente empregados na implementação da etapa
inicial de construção de um compilador – a análise léxica, responsável pela identificação e
classificação das unidades léxicas e o tratamento de erros léxicos. Os Autômatos Finitos podem
ser classificados em Autômatos Finitos Determinísticos, em Autômatos Finitos Não-
Determinísticos e em Autômatos Finitos Não-Determinísticos com Movimento Vazio. Uma
expressão Regular é um dispositivo formal denotacional de uma Linguagem Regular. Neste
trabalho foi desenvolvido um software educacional para construção e validação de formalismos
utilizados na geração e reconhecimento de sentenças de uma Linguagem Regular, permitindo a
construção de Autômatos Finitos e a conversão de Autômatos Finitos Não-Determinísticos com
Movimento Vazio para Autômatos Finitos Não-Determinísticos, de Autômatos Finitos Não-
Determinísticos para Autômatos Finitos Determinísticos e de Autômatos Finitos Determinísticos
para Autômatos Finitos Determinísticos Mínimos, assim como o reconhecimento de sentenças.
Foi utilizada a linguagem de programação Object Pascal no ambiente de programação do Borland
Delphi 7, além de fontes documentais e fontes bibliográficas. O software desenvolvido será
utilizado como apoio no aprendizado de formalismos de uma Linguagem Regular na disciplina de
Linguagens Formais e Compiladores dos cursos de Ciência da Computação e Engenharia da
Computação da Universidade do Vale do Itajaí – UNIVALI, campus São José.
Palavras Chaves: Linguagem Regular, Autômato Finito, Expressão Regular.
7
ABSTRACT
The Theory of Formal Languages makes available a group of formalisms that they can be used
for specification and recognition of sentences of a programming language. The Finite
Automatons are formalisms usually employed in the implementation of the initial stage of a
compiler's construction. The lexical analysis, responsible for the identification and classification
of the lexical units and the treatment of lexical mistakes. The Finite Automatons can be classified
in Finite Automatons Deterministics, in Finite Automatons Non Deterministics and in Finite
Automatons Non Deterministics with Empty Movement. A Regular expression is a device formal
denote of a Regular Language. In this work a education software was developed for construction
and validation of formalisms used in the generation and recognition of sentences of a Regular
Language, allowing the construction of Finite Automatons and the conversion of Finite
Automatons Non Deterministics with Empty Movement for Finite Automatons Non
Deterministics, of Finite Automatons Non Deterministics for Finite Automatons Deterministics
and of Finite Automatons Deterministics for Finite Automatons Deterministics Minimum, as well
as the recognition of sentences. The programming language Object Pascal was used in the
atmosphere of programming of Borland Delphi 7, besides documental sources and
bibliographical sources. The developed tool will be used as support in the learning of formalisms
of a Regular Language in the discipline of Formal Languages and Compilers of the courses of
Science of the Computation and Engineering of the Computation of the University of the valley
of Itajaí. UNIVALI, campus São José.
Key Words: Regular Language, Finite Automatons, Regular Expression.
8
FIGURAS
Figura 1: Hierarquia de Chomsky ............................................................................................................................17 Figura 2: Autômato Finito como uma máquina com controle finito .....................................................................20 Figura 3: exemplo de uma máquina de estados .......................................................................................................20 Figura 4: tabela de transição para o exemplo da Figura 3 .....................................................................................22 Figura 5: diagrama de transição de um Autômato Finito Determinístico.............................................................24 Figura 6: tabela de transição de um Autômato Finito Determinístico...................................................................24 Figura 7: diagrama de transição de um Autômato Finito Não-Determinístico ....................................................26 Figura 8: tabela de transição de um Autômato Finito Não-Determinístico ..........................................................26 Figura 9: diagrama de transição de um Autômato Finito Não-Determinístico com Movimento Vazio .............28 Figura 10: tabela de transição de um Autômato Finito Não-Determinístico com Movimento Vazio .................28 Figura 11: Autômato Finito Não-Determinístico com Movimento Vazio..............................................................30 Figura 12: Autômato Finito Não-Determinístico equivalente ................................................................................30 Figura 13: Autômato Finito Determinístico equivalente.........................................................................................33 Figura 14: Diagrama de transição do Autômato Finito Determinístico ................................................................35 Figura 15: Tabela de transição do Autômato Finito Determinístico com identificação dos estados acessíveis..35 Figura 16: Tabela de transição do Autômato Finito Determinístico sem os estados inacessíveis........................36 Figura 17: Tabela de transição do Autômato Finito Determinístico sem transições indefinidas ........................36 Figura 18: Tabela de equivalência de estados finais e não finais do Autômato Finito Determinístico ...............37 Figura 19: Tabela de conjuntos de equivalência (1° iteração)................................................................................38 Figura 20: Tabela de conjuntos de equivalência (2° iteração)................................................................................38 Figura 21: Tabela de transição do Autômato Finito Determinístico com identificação dos estados não mortos
............................................................................................................................................................................39 Figura 22: Tabela de transição do Autômato Finito Determinístico sem estados mortos....................................39 Figura 23: Tabela de transição do Autômato Finito Determinístico Mínimo .......................................................40 Figura 24: Diagrama de transição do Autômato Finito Determinístico Mínimo..................................................40 Figura 25: Leis algébricas das Expressões Regulares .............................................................................................42 Figura 26: Autômato Finito Não-Determinístico com Movimento Vazio com transição ε ..................................45 Figura 27: Autômato Finito Não-Determinístico com Movimento Vazio com transição .....................................45 Figura 28: Autômato Finito Não-Determinístico com Movimento Vazio resultante da união ............................46 Figura 30: Autômato Finito Não-Determinístico com Movimento Vazio resultante do fechamento ..................47 Figura 31: Autômato Finito para reconhecer a .......................................................................................................47 Figura 32: Autômato Finito para reconhecer b .......................................................................................................48 Figura 33: Autômato Finito Não-Determinístico com Movimento Vazio para reconhecer a | b .........................48 Figura 34: Autômato Finito Não-Determinístico com Movimento Vazio para reconhecer (a | b)* .....................49 Figura 35: Autômato Finito Não-Determinístico com Movimento Vazio para reconhecer (a | b)* a...................49 Figura 36: Caso de Uso Desenhar Autômato ...........................................................................................................54
9
Figura 37: Caso de Uso Imprimir .............................................................................................................................54 Figura 38: Caso de Uso Reconhecer Direto..............................................................................................................55 Figura 39: Caso de Uso Reconhecer Passo a Passo..................................................................................................56 Figura 40: Caso de Uso Tipo de Autômato ..............................................................................................................57 Figura 41: Caso de Uso Converte AFNE para AFN................................................................................................58 Figura 42: Caso de Uso Converte AFN para AFD ..................................................................................................59 Figura 43: Caso de Uso Converte AFD para AFDM...............................................................................................60 Figura 44: Diagrama de Seqüência Imprimir..........................................................................................................61 Figura 45: Diagrama de Seqüência Converter Autômato.......................................................................................61 Figura 46: Diagrama de Seqüência Reconhecer ......................................................................................................62 Figura 47: Diagrama de Seqüência Tipo Autômato ................................................................................................62 Figura 48: Diagrama de Classe do Sistema..............................................................................................................64 Figura 49: Reconhecimento de um Autômato Finito Não Determinístico com Movimento Vazio......................68 Figura 50: Reconhecimento de um Autômato Finito Não Determinístico.............................................................69 Figura 51: Reconhecimento de um Autômato Finito Determinístico.....................................................................69 Figura 52: Reconhecimento de uma sentença aceita de forma direta....................................................................70 Figura 53: Reconhecimento de uma sentença não aceita de forma direta.............................................................71 Figura 54: Reconhecimento de uma sentença aceita passo a passo........................................................................72 Figura 55: Reconhecimento de uma sentença não aceita passo a passo ................................................................73 Figura 56: Conversão de um AFN-ε em um AFN....................................................................................................74 Figura 57: Conversão de um AFN-ε em um AFN com Autômato de entrada errado..........................................75 Figura 58: Conversão de um AFN em um AFD.......................................................................................................76 Figura 59: Conversão de um AFN em um AFD com Autômato de entrada errado.............................................76 Figura 60: Conversão de um AFD em um AFDm ...................................................................................................77 Figura 61: Conversão de um AFD em um AFDm com Autômato de entrada errado..........................................78
10
SUMÁRIO
1 INTRODUÇÃO.................................................................................................................................................12
1.1 CONTEXTUALIZAÇÃO ..........................................................................................................................................12 1.2 PROBLEMA......................................................................................................................................................13 1.3 OBJETIVOS ......................................................................................................................................................14
1.3.1 Objetivo geral .......................................................................................................................................14 1.3.2 Objetivos específicos ............................................................................................................................14 1.3.3 Escopo e delimitação do trabalho ........................................................................................................14
1.4 RESULTADOS ESPERADOS..........................................................................................................................15 1.5 JUSTIFICATIVA ..............................................................................................................................................15 1.6 ASPECTOS METODOLÓGICOS...............................................................................................................................16
1.6.1 Metodologia..........................................................................................................................................16
2 FUNDAMENTAÇÃO TEÓRICA ...................................................................................................................17
2.1 LINGUAGENS FORMAIS E SUAS REPRESENTAÇÕES...............................................................................................17 2.2 AUTÔMATO FINITO..............................................................................................................................................18
2.2.1 Autômatos Finitos Determinísticos.......................................................................................................23 2.2.2 Autômatos Finitos Não-Determinísticos...............................................................................................24 2.2.3 Autômatos Finitos Não-Determinísticos com Movimento Vazio ..........................................................27 2.2.4 Autômatos Finitos Determinísticos Mínimos........................................................................................28 2.2.5 Equivalência dos autômatos finitos ......................................................................................................28
2.2.5.1 Equivalência entre um Autômato Finito Não-Determinístico e um Autômato Finito Não-Determinístico
com Movimento Vazio.....................................................................................................................................................29 2.2.5.2 Equivalência entre um Autômato Finito Não-Determinístico e um Autômato Finito Determinístico.........30
2.3 EXPRESSÃO REGULAR .........................................................................................................................................40 2.3.1 Propriedades das Expressões Regulares..............................................................................................42 2.3.2 Simplificação de Expressões Regulares ...............................................................................................42 2.3.3 Definição Regular.................................................................................................................................43
2.4 AUTÔMATO FINITO X EXPRESSÃO REGULAR .........................................................................................44 2.4.1 Conversão de Expressões Regulares em Autômatos Finitos ................................................................44 2.4.2 Conversão de Autômatos Finitos em Expressões Regulares ................................................................50 2.4.3 Aplicações de Autômatos Finitos e Expressões Regulares...................................................................50
3 DESENVOLVIMENTO DO SOFTWARE ....................................................................................................52
3.1 MODELAGEM .................................................................................................................................................52 3.1.1 Casos de Uso ........................................................................................................................................52 3.1.2 Diagramas de Seqüência ......................................................................................................................60
11
3.1.3 Diagrama de Classe .............................................................................................................................63 3.2 IMPLEMENTAÇÃO.........................................................................................................................................65
3.2.1 Ambiente ...............................................................................................................................................67
4 CONSIDERAÇÕES FINAIS ...........................................................................................................................79
5 REFERÊNCIAS BIBLIOGRAFICAS............................................................................................................81
APÊNDICE.................................................................................................................................................................83
12
1 INTRODUÇÃO
1.1 CONTEXTUALIZAÇÃO
A Teoria de Linguagens Formais disponibiliza um conjunto de formalismos que podem ser
utilizados na especificação e reconhecimento de sentenças de uma linguagem. De acordo com o
lingüista Noam Chomsky, as linguagens podem ser hierarquizadas em Linguagens Regulares,
Linguagens Livres de Contexto, Linguagens Sensíveis ao Contexto e Linguagens Enumeráveis
Recursivamente ou Irrestritas, em ordem crescente de abrangência e complexidade. (MENEZES,
2002).
Um reconhecedor é um sistema que a partir de um conjunto de símbolos que constituem a
sentença, aceita ou rejeita a sentença como sendo ou não uma sentença válida para uma
determinada linguagem. Os Autômatos Finitos são dispositivos formais utilizados no
reconhecimento de sentenças de uma Linguagem Regular. (AHO; SETHI; ULLMAN, 1995).
Os Autômatos Finitos podem ser classificados em Autômatos Finitos Determinísticos, em
Autômatos Finitos Não-Determinísticos e em Autômatos Finitos Não-Determinísticos com
Movimento Vazio, existindo uma equivalência de poder de reconhecimento entre os grupos de
Autômatos Finitos. (AHO; SETHI; ULLMAN, 1995). Ainda, para qualquer Autômato Finito
Não-Determinístico existe sempre outro Autômato Finito Determinístico que reconhece a mesma
linguagem. (HOPCROFT; ULLMAN; MOTWANI, 2002).
Toda Linguagem Regular pode ser descrita por uma expressão simples, denominada Expressão
Regular. (AHO; SETHI; ULLMAN, 1995; HOPCROFT; ULLMAN; MOTWANI, 2002;
MENEZES, 2002; PRICE; TOSCANI, 2001). As Expressões Regulares são formalismos
denotacionais que estabelecem um modo declarativo – descrição algébrica – de representar
sentenças de uma linguagem, sendo também consideradas dispositivos geradores, pois a partir de
uma Expressão Regular é possível inferir como gerar sentenças de uma determinada linguagem.
Uma Linguagem Regular pode ser denotada por uma ou mais Expressões Regulares.
Apesar da abordagem de Expressão Regular para denotar linguagens ser fundamentalmente
distinta da abordagem de Autômatos Finitos, estes dispositivos representam o mesmo conjunto de
linguagens, as Linguagens Regulares. (HOPCROFT; ULLMAN; MOTWANI, 2002).
13
Dentro deste contexto, este trabalho procura fazer uma contribuição na geração e reconhecimento
de sentenças de uma Linguagem Regular a partir dos formalismos de Expressão Regular e
Autômato Finito.
1.2 PROBLEMA
As Expressões Regulares e os Autômatos Finitos são formalismos usualmente empregados na
implementação da etapa inicial de construção de um compilador – a análise léxica, responsável
pela identificação e classificação das unidades léxicas e o tratamento de erros léxicos. (AHO;
SETHI; ULLMAN, 1995; JOSÉ NETO, 1987). Na análise léxica, os Autômatos Finitos são
construídos a partir das especificações feitas com o uso das Expressões Regulares. Existe uma
correspondência natural entre estes dispositivos, visto que toda linguagem aceita por um
Autômato Finito é definida por uma Expressão Regular e toda linguagem denotada por uma
Expressão Regular também é reconhecida por um Autômato Finito. (HOPCROFT; ULLMAN;
MOTWANI, 2002).
Os Autômatos Finitos Não-Determinísticos e os Autômatos Finitos Não-Determinísticos com
Movimento Vazio são mais abrangentes e menos restritivos que os Autômatos Finitos
Determinísticos. No entanto, exigem técnicas de backtracking quando de sua implementação, o
que implica em um tempo maior para efetuar a análise da sentença. Os Autômatos Finitos
Determinísticos em geral são mais difíceis de serem especificados, mas mais eficientes no
reconhecimento de sentenças. (AHO; SETHI; ULLMAN, 1995; HOPCROFT; ULLMAN;
MOTWANI, 2002).
Todo Autômato Finito Não-Determinístico com Movimento Vazio pode ser convertido em um
Autômato Finito Não-Determinístico e todo Autômato Finito Não-Determinístico pode ser
convertido em um Autômato Finito Determinístico. Entretanto, o Autômato Finito Determinístico
resultante dessa conversão pode apresentar um número consideravelmente maior de estados que o
Autômato Finito Não-Determinístico equivalente, exigindo, portanto, mais espaço para sua
representação. Contudo, também é possível, sempre, encontrar um Autômato Finito
Determinístico Mínimo equivalente a qualquer Autômato Finito Determinístico, apresentando um
número reduzido de estados e ainda assim reconhecendo as mesmas sentenças aceitas pelo
Autômato Finito Determinístico.
14
1.3 OBJETIVOS
1.3.1 Objetivo geral
Desenvolver um software educacional para construção e validação de formalismos utilizados na
geração e reconhecimento de sentenças de uma Linguagem Regular.
1.3.2 Objetivos específicos
realizar um estudo sobre Autômatos Finitos e Expressão Regular, bem como as suas
equivalências, conversões e algoritmos;
realizar a modelagem do software;
implementar e testar o software;
estimular o aprendizado autônomo através de um aplicativo que possibilite a auto-
aprendizagem;
assistir e servir de apoio aos alunos da disciplina de Linguagens Formais e Compiladores
dos cursos de Ciência da Computação e Engenharia de Computação da Universidade do
Vale do Itajaí – UNIVALI, campus São José, na construção e validação dos formalismos
utilizados para reconhecer e gerar sentenças de uma Linguagem Regular,
complementando discussões e exercícios resolvidos em sala de aula.
1.3.3 Escopo e delimitação do trabalho
Assim como os Autômatos Finitos e as Expressões Regulares, as Gramáticas Regulares são
sistemas formais de uma Linguagem Regular. Através de uma Gramática Regular é possível
obter um conjunto de sentenças de uma linguagem particular, sendo, portanto, um dispositivo
gerador de sentenças.
Este trabalho estabelece a elaboração de um software educacional que permita a construção de
Autômatos Finitos e a conversão de Autômatos Finitos Não-Determinísticos com Movimento
Vazio para Autômatos Finitos Não-Determinísticos, de Autômatos Finitos Não-Determinísticos
para Autômatos Finitos Determinísticos e de Autômatos Finitos Determinísticos para Autômatos
Finitos Determinísticos Mínimos. Através do software também será possível encontrar o
15
Autômato Finito equivalente a uma Expressão Regular qualquer, assim como reconhecer
sentenças de uma Linguagem Regular.
Não pertence ao escopo deste trabalho abordar o formalismo de Gramática Regular.
1.4 RESULTADOS ESPERADOS
O desenvolvimento do trabalho possibilitará a especificação de uma Linguagem Regular através
de Autômatos Finitos e Expressões Regulares com o uso de um software educacional. A
expectativa com o uso sistematizado do software é que a aprendizagem da Teoria de Linguagens
Formais, em particular dos formalismos de Linguagens Regulares, seja facilitada aos alunos e que
o aplicativo possa ser uma complementação às discussões promovidas em sala de aula. Este
trabalho apresenta ainda uma contribuição para a aplicação de uma prática pedagógica inovadora.
1.5 JUSTIFICATIVA
Os formalismos de Expressão Regular e Autômatos Finitos são amplamente utilizados na
construção de compiladores, em particular, na implementação do analisador léxico.
Apesar de serem considerados dispositivos formais simples, o forte caráter matemático que os
sustenta impõe resistência para o seu uso e se observa dificuldade para se fazer a sua validação.
Em geral, não é fácil verificar se uma Expressão Regular tem um determinado Autômato Finito
como correspondente ou se dado um Autômato Finito qualquer uma Expressão Regular o
representa ou ainda se um Autômato Finito Determinístico é mínimo e equivalente a um
Autômato Finito Não-Determinístico ou a um Autômato Finito Não-Determinístico com
Movimento Vazio. Também para muitas situações é complexo diagnosticar se uma sentença
pertence ou não à linguagem definida por uma Expressão Regular ou por um Autômato Finito.
O desenvolvimento deste trabalho permitirá construir Autômatos Finitos e Expressões Regulares
e validar os diferentes tipos de Autômatos Finitos (Autômatos Finitos Determinísticos,
Autômatos Finitos Não-Determinísticos e Autômatos Finitos Não-Determinísticos com
Movimento Vazio), possibilitando verificar se para uma dada Expressão Regular o
correspondente Autômato Finito foi construído. As sentenças serão reconhecidas a partir de um
Autômato Finito que representa uma Linguagem Regular particular.
16
Assim, com este trabalho será possível realizar a validação das especificações de uma linguagem
de programação feitas através de Expressões Regulares e a subseqüente construção dos
correspondentes Autômatos Finitos e a implementação de analisadores léxicos dos compiladores
da disciplina de Linguagens Formais e Compiladores dos cursos de Ciência da Computação e
Engenharia de Computação da Universidade do Vale do Itajaí – UNIVALI, campus São José.
1.6 ASPECTOS METODOLÓGICOS
1.6.1 Metodologia
Cervo e Bervian (1996) estabelecem que em um trabalho de natureza aplicada o pesquisador
busca uma solução mais imediata para o problema proposto. De acordo com Jung (2005), “uma
pesquisa que utiliza conhecimentos básicos, tecnologias existentes, conhecimentos tecnológicos e
que tenha como objeto um novo produto ou processo é caracterizado como tecnológica”. Tendo
em vista que o trabalho proposto visa o desenvolvimento de um software educacional, o mesmo
se adequa em um trabalho de natureza aplicada ou tecnológica.
Ainda, Silva e Menezes (2000) afirmam que do ponto de vista do problema, o trabalho pode ser
classificado como qualitativo, pois não serão utilizados métodos estatísticos como amostragem
probabilística, amostragem não-probabilística entre outras.
Considerando os objetivos definidos no trabalho, a pesquisa exploratória foi a que se mostrou
mais adequada para o seu desenvolvimento. Como definem Cervo e Bervian (1996), a pesquisa
exploratória não elabora hipóteses e sim se limita à definição de objetivos e a busca de
informações sobre um determinado assunto, a qual se realiza através de fontes documentais e
fontes bibliográficas.
17
2 FUNDAMENTAÇÃO TEÓRICA
2.1 LINGUAGENS FORMAIS E SUAS REPRESENTAÇÕES
Entende-se por Teoria das Linguagens Formais e dos Autômatos o estudo de
modelos matemáticos que possibilitam a especificação e o reconhecimento de
linguagens1 (no sentido amplo da palavra), suas classificações, estruturas,
propriedades, características e inter-relacionamentos. (FURTADO, p.6).
As Linguagens Formais são dispositivos com sustentação matemática baseadas na Teoria da
Computação, usadas na especificação e representação de linguagens. A teoria das Linguagens
Formais foi desenvolvida a partir dos anos 50 para possibilitar estudos relacionados com as
linguagens naturais. No entanto, foi verificado que essa teoria tinha aplicação no estudo das
linguagens artificiais, como em linguagens de programação.
O lingüista Noam Chomsky apud (MENEZES, 2002) definiu uma classificação para as
linguagens, conhecida como hierarquia de Chomsky conforme Figura 1.
LINGUAGEM ENUMERÁVEL RECURSIVAMENTE
LINGUAGEM SENSÍVEL AO CONTEXTO
LINGUAGEM LIVRE DE CONTEXTO
LINGUAGEM REGULAR
Figura 1: Hierarquia de Chomsky Fonte: (MENEZES, 2002)
1 Uma linguagem é um conjunto de elementos (símbolos) e métodos (regras) para combinar estes elementos na formação de sentenças, usado e entendido por uma comunidade. As linguagens podem ser finitas ou infinitas. Uma linguagem finita pode ser definida pela enumeração das sentenças constituintes ou através de uma descrição algébrica. Uma linguagem infinita é definida com uma representação finita. Reconhecedores e geradores são representações finitas para linguagens. (WIKIPEDIA, 2005).
18
As Linguagens Regulares compreendem o conjunto de “linguagens mais simples, sendo possível
desenvolver algoritmos de reconhecimento ou geração de pouca complexidade, grande eficiência
e de fácil implementação”. (MENEZES, 2002, p.32). Essas linguagens podem ser denotadas por
Expressões Regulares, reconhecidas por Autômatos Finitos e geradas através de Gramáticas
Regulares. De acordo com HOPCROFT; ULLMAN; MOTWANI (2002), muitos problemas
podem ser desenvolvidos mais facilmente a partir da especificação feita em termos de Expressões
Regulares e a subseqüente transformação para o Autômato Finito correspondente. O
desenvolvimento de analisadores léxicos, editores de texto, sistemas de pesquisa, linguagens de
comunicação homem-máquina são algumas das possibilidades de aplicação dos formalismos das
Linguagens Regulares.
As Linguagens Livre de Contexto permitem a adequada especificação das estruturas sintáticas de
linguagens de programação, visto que a maioria das linguagens de programação são classificadas
como Linguagens Livre de Contexto e podem, portanto, ser geradas e reconhecidas através dos
formalismos de Gramática Livre de Contexto e Autômato de Pilha, respectivamente. Assim,
dentre as possíveis aplicações das Linguagens Livre de Contexto estão a especificação de
linguagens de programação e a implementação de analisadores sintáticos e de tradutores de
linguagens.
As Linguagens Sensíveis ao Contexto e Enumeráveis Recursivamente “permitem explorar os
limites da capacidade de desenvolvimento de reconhecedores ou geradores de linguagens”.
Máquina de Turing com fita limitada e Gramática Sensível ao Contexto são os formalismos
reconhecedores e geradores das Linguagens Sensíveis ao Contexto. As Linguagens Enumeráveis
Recursivamente são geradas através de Gramáticas Enumeráveis Recursivamente e reconhecidas
por Máquina de Turing.
2.2 AUTÔMATO FINITO
Os Autômatos Finitos são dispositivos reconhecedores de grande importância na computação.
Usualmente os Autômatos Finitos são utilizados na identificação, classificação das unidades
léxicas ou tokens2 e tratamento dos erros léxicos de uma linguagem e na implementação da parte
2 “Um token é uma seqüência de caracteres com um significado coletivo” (AHO; SETHI; ULLMAN, 1995). As palavras reservadas, os identificadores, as constantes numéricas e literais, os símbolos especiais e comentários são exemplos de unidades léxicas ou tokens.
19
inicial de um compilador – a análise léxica. O analisador léxico é o componente responsável por
obter as unidades mínimas significativas do programa-fonte (lexemas3) que está sendo analisado
e classificá-las apropriadamente. Nesta fase da análise, o programa é lido caractere a caractere e
por isso, o desempenho de um analisador léxico tem impacto direto sobre o desempenho do
compilador. (AHO; SETHI; ULLMAN, 1995; JOSÉ NETO, 1987).
Segundo MENEZES (2002) um Autômato Finito pode ser visto como uma máquina de estados
composta essencialmente de três partes (Figura 2):
fita: dispositivo de entrada que contém a sentença4 a ser analisada. A fita é finita à
esquerda e à direita e divide-se em células onde cada célula armazena um símbolo5, o
qual pertence a um alfabeto6 de entrada. A fita não permite gravação e nem possui
memória auxiliar. Inicialmente a fita encontra-se totalmente ocupada pela palavra a ser
processada (informação de entrada da máquina);
unidade de controle: reflete o estado corrente da máquina e realiza seus movimentos. A
leitura é realizada através da cabeça da fita, a qual acessa uma unidade da fita de cada
vez, movimentando-se apenas para a direita. A posição inicial da cabeça de leitura é o
mais a esquerda possível da fita. A unidade de controle possui um número finito e
predefinido de estados7;
função de transição: função que comanda a leitura dos símbolos da fita e define o estado
da máquina. Dependendo do estado corrente e do símbolo lido, um novo estado é
determinado para o autômato. Como os autômatos não têm memória de trabalho para
armazenar informações para o próximo processamento é necessário trabalhar com o
conceito de estados.
3 “Lexema é um conjunto de caracteres no programa fonte que é reconhecido pelo padrão de algum token” (AHO; SETHI; ULLMAN, 1995). 4 “Sentença é uma seqüência finita de símbolos retirados do mesmo alfabeto” (AHO; SETHI; ULLMAN, 1995). 5 Um símbolo é uma entidade abstrata elementar que não possui uma definição formal. Um símbolo pode ser qualquer caractere – uma letra, um dígito, um caractere de pontuação, acentuação, um caractere especial etc. 6 “Alfabeto é qualquer conjunto finito de símbolos” (AHO; SETHI; ULLMAN, 1995). 7 Um estado corresponde a uma situação particular no processo de reconhecimento.
20
Figura 2: Autômato Finito como uma máquina com controle finito Fonte: (MENEZES, 2002)
Para uma melhor compreensão da definição de máquina de estado finito ou Autômato Finito
pode-se admitir a existência de uma máquina imaginária que possa assumir os estados de
repouso, atividade e manutenção. A representação através de um Autômato Finito pode ser
observada na Figura 3.
manutenção
atividade repouso
OK
OFF
ON
início
PANE
Figura 3: exemplo de uma máquina de estados Fonte: (ZILLER, 1997)
Inicialmente a máquina está em repouso. A máquina entra em atividade quando é acionado o
evento ON e volta para o repouso quando seu evento OFF é acionado automaticamente após a
produção. Assim o correto funcionamento da máquina é caracterizado por uma seqüência de
eventos ON e OFF. No entanto, pode ser que durante o período de atividade da máquina ocorra
um problema e neste caso, o evento PANE será acionado, mudando o estado da máquina para
manutenção. Após a resolução do problema a máquina volta para o estado repouso com o evento
OK.
Os Autômatos Finitos têm a capacidade de reconhecer uma sentença e retornar se esta pertence
ou não a uma determinada Linguagem Regular. Assim, pode-se dizer que o Autômato Finito é o
21
tipo mais simples de reconhecedor de linguagens. (MENEZES, 2002; PRICE; TOSCANI, 2001;
HOPCROFT; ULLMAN; MOTWANI, 2002).
Existem três notações ou formas de representação de Autômatos Finitos: representação formal,
diagramas de transição e tabelas de transição.
Representação Formal
Formalmente um Autômato Finito é uma quíntupla M = (Q, Σ, δ, q0, F), onde:
Q - conjunto finito e não vazio de estados possíveis;
Σ - alfabeto de símbolos de entrada;
δ - função de transição8;
q0 - estado inicial (q0 ∈ Q);
F - conjunto de estados finais (F ⊆ Q).
A máquina de estados da Figura 3 pode ser representada formalmente através do Autômato Finito
Mmáquina = (Q, Σ, δ, q0, F), onde:
Q = {repouso, atividade, manutenção}
Σ = {ON, OFF, PANE, OK}
δ = {δ (repouso, ON) = atividade,
δ (atividade, OFF) = repouso,
δ (atividade, PANE) = manutenção,
δ (manutenção, OK) = repouso}
q0 = repouso
F = {repouso}
Representação através de diagrama de transição
Um diagrama de transição é um grafo direcionado onde os vértices (círculos) representam os
estados e as arestas (linhas) representam as transições9 (Figura 3). (HOPCROFT; ULLMAN; 8 A função de transição ou de mapeamento δ determina o estado qnovo a partir do estado qatual e do símbolo de entrada x. Simbolicamente, δ (qatual, x) = qnovo.
22
MOTWANI, 2002; MENEZES, 2002). O estado inicial é representado com uma seta na frente do
respectivo estado e o (s) estado (s) final (is) é (são) representado por um círculo duplo.
Entre dois estados qi, qj existirá uma aresta direcionada de qi para qj com rótulo x se x ∈ Σ e ∃ δ
(qi, x) = qj. Na Figura 3 existe uma aresta rotulada com ON do estado repouso para o estado
atividade porque ∃ δ (repouso, ON) = atividade.
Representação através de tabela de transição
A tabela de transição é uma tabela onde as linhas representam os estados (o estado inicial é
indicado com uma seta em frente do estado referente a ele e o estado final é indicado por um
asterisco em frente do estado referente a ele), as colunas representam os símbolos de entrada e o
conteúdo da posição (qi, x) será igual à qj, se ∃ δ (qi, x) = qj; caso contrário será indefinido.
(HOPCROFT; ULLMAN; MOTWANI, 2002; MENEZES, 2002).
A Figura 4 ilustra a tabela de transição do Autômato Finito correspondente à máquina hipotética
da Figura 3.
δ ON OFF PANE OK
→* repouso atividade - - -
atividade - repouso manutenção -
manutenção - - - repouso Figura 4: tabela de transição para o exemplo da Figura 3
Fonte: (ZILLER, 1997)
Os Autômatos Finitos podem ser classificados em Autômatos Finitos Determinísticos, Autômatos
Finitos Não-Determinísticos, e Autômatos Finitos Não-Determinísticos com Movimento Vazio.
(PRICE; TOSCANI, 2001; HOPCROFT; ULLMAN; MOTWANI, 2002; AHO; SETHI;
ULLMAN, 1995).
9 Uma transição de estado é a mudança de um estado para outro (MENEZES, 2002).
23
2.2.1 Autômatos Finitos Determinísticos
Um Autômato Finito Determinístico (AFD) é um caso especial do Autômato Finito Não-
Determinístico, no qual nenhum estado possui ε-transições10 e para todos os estados
independentes do símbolo de entrada existe apenas uma transição possível para cada símbolo do
alfabeto. (HOPCROFT; ULLMAN; MOTWANI, 2002; AHO; SETHI; ULLMAN, 1995).
Uma definição formal para Autômato Finito Determinístico é estabelecida através da quíntupla M
= (Q, ∑, δ, q0, F). (PRICE; TOSCANI, 2001; MENEZES, 2002; HOPCROFT; ULLMAN;
MOTWANI, 2002), onde:
Q - conjunto finito e não vazio de estados possíveis;
∑ - alfabeto de símbolos de entrada;
δ - função de transição δ : Q x ∑ Q, a qual é uma função parcial11;
q0 - estado inicial (q0 ∈ Q);
F - conjunto de estados finais (F ⊆ Q).
A função de transição δ : Q x ∑ Q corresponde a δ (qi, x) = qj e a interpretação é reconhecer x
se x for o próximo símbolo da entrada, o estado atual for qi e avançar para o estado qj.
A representação de Autômatos Finitos Determinísticos através de diagramas de transição e
através de tabelas de transição pode ser observada nas Figuras 5 e 6, respectivamente. O referido
Autômato Finito Determinístico M = ({q0, q1, q2, q3}, {a, b}, δ, q0, {q3}) reconhece a linguagem
dada por L = {w ⎪ |w| ≥ 2 e w possui aa ou bb como subsentença}, ou seja, toda sentença w
tomada sobre um alfabeto {a, b}, de tamanho maior ou igual a dois e que tem as seqüências aa ou
bb como subsentenças. (MENEZES, 2002; HOPCROFT; ULLMAN; MOTWANI, 2002).
10 ε-transições são transições rotuladas por ε. A semântica dessas transições é de que o estado se altera, sem que seja consumido um símbolo da entrada. 11 “Função parcial é uma relação onde cada elemento do domínio está relacionado com, no máximo, um elemento do contradomínio” (MENEZES, 2002).
24
q3
q1
q0
q2
a, b
a
a
a b
b
b
início
Figura 5: diagrama de transição de um Autômato Finito Determinístico Fonte: (MENEZES, 2002)
δ a b
→ q0 q1 q2
q1 q3 q2
q2 q1 q3
* q3 q3 q3
Figura 6: tabela de transição de um Autômato Finito Determinístico Fonte: (MENEZES, 2002)
2.2.2 Autômatos Finitos Não-Determinísticos
Analogamente ao Autômato Finito Determinístico, o Autômato Finito Não-Determinístico (AFN)
é um modelo matemático definido através de uma quíntupla que difere do Autômato Finito
Determinístico apenas no tipo da função de transição. Para um Autômato Finito Não-
Determinístico, como nos Autômatos Finitos Determinísticos, δ é uma função de transição que
recebe um estado e um símbolo como argumentos, mas diferentemente do Autômato Finito
25
Determinístico retorna um conjunto de zero, uma ou mais transições de estados. (HOPCROFT;
ULLMAN; MOTWANI, 2002; AHO; SETHI; ULLMAN, 1995).
A facilidade do não-determinismo nem sempre aumenta o poder de reconhecimento de
linguagens, pois o Autômato Finito Não-Determinístico aceita apenas Linguagens Regulares,
assim como o Autômato Finito Determinístico. A grande vantagem que o Autômato Finito Não-
Determinístico tem sobre o Autômato Finito Determinístico é a facilidade de seu projeto, visto
que são menos restritivos. (HOPCROFT; ULLMAN; MOTWANI, 2002; MENEZES, 2002).
Um Autômato Finito Não-Determinístico é definido pela quíntupla M = (Q, ∑, δ, q0, F). (PRICE;
TOSCANI, 2001; MENEZES, 2002; HOPCROFT; ULLMAN; MOTWANI, 2002), onde:
Q - conjunto finito e não vazio de estados possíveis;
∑ - alfabeto de símbolos de entrada;
δ - função de transição δ : Q x ∑ 2Q, a qual é uma função parcial;
q0 - estado inicial (q0 ∈ Q);
F - conjunto de estados finais (F ⊆ Q).
A função de transição δ : Q x ∑ 2Q corresponde a δ (qi, x) = {qj1, qj2, ..., qjn} e a interpretação é
reconhecer x se x for o próximo símbolo de entrada, o estado atual for qi e avançar para o estado
qj1 ou para o estado qj2 ou ... ou para o estado qjn.
Assim como os Autômatos Finitos Determinísticos, os Autômatos Finitos Não-Determinísticos
podem ser representados através de diagramas de transição e de tabelas de transição.
(MENEZES, 2002; HOPCROFT; ULLMAN; MOTWANI, 2002; AHO; SETHI; ULLMAN,
1995).
No diagrama de transição a representação se realiza de maneira análoga a dos Autômatos Finitos
Determinísticos. A única diferença é que a partir de um determinado estado pode-se assumir mais
de uma transição (mais de um caminho) para um mesmo símbolo do alfabeto (Figura 7). (AHO;
SETHI; ULLMAN, 1995).
26
q0 início q1 q2 q3
a
a
b
bb
Figura 7: diagrama de transição de um Autômato Finito Não-Determinístico Fonte: (AHO; SETHI; ULLMAN, 1995)
A linguagem reconhecida pelo Autômato Finito Não-Determinístico representado na Figura 7
corresponde ao conjunto de sentenças formadas pelos símbolos {a, b} e que terminam com a
seqüência abb. O não-determinísmo é observado na transição do estado q0 com o símbolo a.
A tabela de transição do Autômato Finito Não-Determinístico é análoga a do Autômato Finito
Determinístico. A diferença está no conteúdo de cada posição (qi, x) que poderá conter um
conjunto de zero ou mais estados qj. (HOPCROFT; ULLMAN; MOTWANI, 2002; AHO;
SETHI; ULLMAN, 1995).
A representação através de tabelas de transição oferece uma grande vantagem por dar acesso
rápido às transições; entretanto, pode ocupar muito espaço quando o alfabeto for grande e as
transições forem na maioria indefinidas. (HOPCROFT; ULLMAN; MOTWANI, 2002; AHO;
SETHI; ULLMAN, 1995).
A tabela de transição correspondente ao Autômato Finito Não-Determinístico da Figura 7 é
apresentada na Figura 8.
δ a b
→ q0 {q0, q1} q0
q1 - q2
q2 - q3
* q3 - - Figura 8: tabela de transição de um Autômato Finito Não-Determinístico
Fonte: (AHO; SETHI; ULLMAN, 1995)
27
2.2.3 Autômatos Finitos Não-Determinísticos com Movimento Vazio
Um Autômato Finito Não-Determinístico pode ser generalizado incluindo transições com o
movimento vazio ou ε, que segundo MENEZES (2002) podem ser vistas como um não-
determinismo interno dos Autômatos.
Como os Autômatos Finitos Não-Determinísticos, os Autômatos Finitos Não-Determinísticos
com Movimento Vazio (AFN-ε) não aumentam o poder de reconhecimento de linguagens.
Entretanto possuem a vantagem de serem mais fáceis de projetar e facilitar algumas construções e
demonstrações relacionadas ao formalismo de Autômatos Finitos. (MENEZES, 2002;
HOPCROFT; ULLMAN; MOTWANI, 2002).
Um Autômato Finito Não-Determinístico com Movimento Vazio pode ser definido formalmente
como uma quíntupla M = (Q, ∑, δ, q0, F). (PRICE; TOSCANI, 2001; MENEZES, 2002;
HOPCROFT; ULLMAN; MOTWANI, 2002), onde:
Q - conjunto finito e não vazio de estados possíveis;
∑ - alfabeto de símbolos de entrada;
δ - função de transição δ : Q x (∑ U {ε}) 2Q, a qual é uma função parcial;
q0 - estado inicial (q0 ∈ Q);
F - conjunto de estados finais (F ⊆ Q).
A função de transição do Autômato Finito Não-Determinístico com Movimento Vazio é
equivalente à função de transição do Autômato Finito Não-Determinístico, diferenciando-se
apenas em relação ao alfabeto de entrada que admite o símbolo ε.
O diagrama de transição e a tabela de transição correspondentes ao Autômato Finito Não-
Determinístico com Movimento Vazio que reconhece a linguagem L = {w ⎪ w ∈ {a, b} e w é
formado por qualquer quantidade de a’s, seguida por qualquer quantidade de b’s} são
apresentados nas Figuras 9 e 10, respectivamente.
28
q0 início q1 ε
a b
Figura 9: diagrama de transição de um Autômato Finito Não-Determinístico com Movimento Vazio Fonte: (MENEZES, 2002)
O Autômato Finito Não Determinístico com Movimento Vazio representado pelo diagrama de
transição da Figura 9, reconhece a linguagem denotada por L = {w| qualquer número de símbolos
a seguidos de um ou mais símbolos b}.
δ a b ε
→q0 {q0} - {q1}
* q1 - q1 - Figura 10: tabela de transição de um Autômato Finito Não-Determinístico com Movimento Vazio
Fonte: (MENEZES, 2002)
2.2.4 Autômatos Finitos Determinísticos Mínimos
A transformação de um Autômato Finito Determinístico para um Autômato Finito Determinístico
Mínimo (AFDm) tem como objetivo gerar um Autômato Finito equivalente que possui um
número reduzido de estados. Para cada linguagem existe um único Autômato Finito
Determinístico Mínimo, ou seja, dois Autômatos Finitos Determinísticos diferentes, mas que
aceitam a mesma linguagem, ao serem minimizados resultam no mesmo Autômato Finito
Determinístico Mínimo, diferenciando-se apenas na identificação dos estados. (MENEZES,
2002).
2.2.5 Equivalência dos autômatos finitos
A equivalência entre Autômatos Finitos é a forma de demonstrar que Autômatos Finitos
Determinísticos podem reconhecer uma mesma Linguagem Regular que os Autômatos Finitos
Não-Determinísticos.
29
2.2.5.1 Equivalência entre um Autômato Finito Não-Determinístico e um Autômato Finito
Não-Determinístico com Movimento Vazio
Segundo MENEZES (2002), a classe dos Autômatos Finitos Não-Determinísticos com
Movimento Vazio é equivalente à classe dos Autômatos Finitos Não-Determinísticos.
Ainda segundo MENEZES (2002), a prova para esta equivalência é mostrar que se pode obter um
Autômato Finito Não-Determinístico que reconheça as mesmas sentenças que são reconhecidas
por um Autômato Finito Não-Determinístico com Movimento Vazio.
Algoritmo para transformação de um Autômato Finito Não-Determinístico com Movimento
Vazio para um Autômato Finito Não-Determinístico
O algoritmo consiste em construir uma função de transição sem movimentos vazios, onde o
conjunto de estados destino de cada transição não vazia é aumentada com todos os estados
possíveis de serem atingidos com transições vazias. (MENEZES, 2002).
ENTRADA: um AFN-ε M = (Q, ∑, δ, q0, F).
SAÍDA: um AFN M’ = (Q, ∑, δ’, q0, F’), tal que M ≡ M’.
δ’ – função de transição tal que δ’: Q x Σ → 2Q, onde δ’ (q, x) = δ ({q}, x);
F’ – conjunto de todos os estados q ∈ Q tal que algum elemento de FECHO12-ε (q)
pertence a F.
Exemplo de transformação de um Autômato Finito Não-Determinístico com Movimento Vazio
para um Autômato Finito Não-Determinístico
Seja o Autômato Finito Não-Determinístico com Movimento Vazio M = (Q, ∑, δ, q0, F)
representado pela Figura 11.
12 A função FECHO-ε (q) é dada por:
i. FECHO-ε (q) = {q}, se δ (q, ε) é indefinida; ii. FECHO-ε (q) = {q} ∪ δ (q, ε) ∪ (∪p em c FECHO-ε (p)), caso contrário.
30
q0 q1 q2
a ab
εεinício
Figura 11: Autômato Finito Não-Determinístico com Movimento Vazio Fonte: (MENEZES, 2002)
O Autômato Finito Não-Determinístico M’ = (Q, ∑, δ’, q0, F’) equivalente pode ser observado na
Figura 12.
a, b
q2
a ab
a, binício q1 q0
a, b
Figura 12: Autômato Finito Não-Determinístico equivalente Fonte: (MENEZES, 2002)
2.2.5.2 Equivalência entre um Autômato Finito Não-Determinístico e um Autômato Finito
Determinístico
Embora existam muitas linguagens para as quais os Autômatos Finitos Não-Determinísticos as
representam mais adequadamente, sua construção e implementação é mais complexa e custosa,
pois requer algoritmos de backtracking (recursivos). (HOPCROFT; ULLMAN; MOTWANI,
2002).
Geralmente um Autômato Finito Determinístico possui um número de estados semelhante a um
Autômato Finito Não-Determinístico, embora seu número de transições frequentemente seja
maior. Considerando o pior caso, o menor Autômato Finito Determinístico possível pode ter 2n
estados, para um Autômato Finito Não-Determinístico de n estados. (HOPCROFT; ULLMAN;
MOTWANI, 2002).
31
Para provar que os Autômatos Finitos Determinísticos são equivalentes aos Autômatos Finitos
Não-Determinísticos basta provar que é possível a construção de um Autômato Finito
Determinístico a partir de um Autômato Finito Não-Determinístico para uma mesma Linguagem
Regular. (MENEZES, 2002).
Algoritmo de transformação de um Autômato Finito Não-Determinístico para um Autômato
Finito Determinístico
A construção de Autômato Finito Determinístico a partir de um Autômato Finito Não-
Determinístico que reconheça a mesma linguagem é feita pela aplicação de um algoritmo
chamado “construção de conjuntos” o qual objetiva construir todos os subconjuntos do conjunto
de estados do Autômato Finito Não-Determinístico. (HOPCROFT; ULLMAN; MOTWANI,
2002; AHO; SETHI; ULLMAN, 1995).
ENTRADA: um AFN M = (Q, ∑, δ, q0, F).
SAIDA: um AFD M’ = (Q’, ∑’, δ’, q0’, F’), tal que M ≡ M’.
A construção dos subconjuntos a partir do Autômato Finito Não-Determinístico M = (Q, ∑, δ, q0,
F), produz o Autômato Finito Determinístico M’ = (Q’, ∑’, δ’, q0’, F’), onde M ≡ M’ e a
linguagem reconhecida pelo Autômato M é também aceita pelo Autômato M’, sendo:
Q’ – conjunto de subconjuntos de Q (conjunto potência de Q);
se Q tem n estados, Q’ terá 2n estados (usualmente nem todos esses estados serão
acessíveis a partir do estado inicial de Q’ e poderão ser eliminados);
Σ' – alfabeto dos símbolos de entrada, tal que Σ' = Σ;
δ’ – função de transição
para cada conjunto C ⊆ Q e para cada símbolo de entrada x em
Σ, δ’ (C, x) = ∪p em c δ (p, x)
(o mapeamento δ’ (C, x) é a união dos estados que M alcança a partir de p com a
entrada x, para todos os estados p em C para os quais ∃ δ (p, x) );
q0’ – estado inicial
conjunto que contém q0;
32
F’ – conjunto de estados finais
conjunto de subconjuntos C para os quais C ∩ F ≠ Ø (são todos os conjuntos de
estados que incluem ao menos um estado final F de M).
Exemplo de transformação de um Autômato Finito Não-Determinístico para um Autômato Finito
Determinístico
Seja M = ({q0, q1, q2, q3, q4}, {a, b}, δ, q0, {q2, q4}), onde:
δ = {δ (q0, a) = (q0, q3),
δ (q0, b) = (q0, q1),
δ (q1, b) = q2,
δ (q2, a) = q2,
δ (q2, b) = q2,
δ (q3, a) = q4,
δ (q4, a) = q4,
δ (q4, b) = (q4)}
O Autômato Finito Determinístico M’ equivalente é representado pela tabela de transição da
Figura 13.
δ a b
→ q0 {q0, q3} {q0, q1}
{q0, q3} {q0, q3, q4} {q0, q1}
{q0, q1} {q0, q3} {q0, q1, q2}
* {q0, q3, q4} {q0, q3, q4} {q0, q1, q4}
* {q0, q1, q2} {q0, q2, q3} {q0, q1, q2}
* {q0, q1, q4} {q0, q3, q4} {q0, q1, q2, q4}
* {q0, q2, q3} {q0, q2, q3, q4} {q0, q1, q2}
33
* {q0, q1, q2, q4} {q0, q2, q3, q4} {q0, q1, q2, q4}
* {q0, q2, q3, q4} {q0, q2, q3, q4} {q0, q1, q2, q4} Figura 13: Autômato Finito Determinístico equivalente
Para transformar um Autômato Finito Determinístico para um Autômato Finito Determinístico
Mínimo equivalente o Autômato Finito não pode possuir estados inacessíveis (estados que nunca
são alcançados a partir de um estado inicial), não pode possuir transições indefinidas (a partir de
qualquer estado com qualquer símbolo do alfabeto de entrada não pode existir transições não
previstas) e não pode possuir estados mortos (estados não finais a partir dos quais não se alcança
algum estado final.). (AHO; SETHI; ULLMAN, 1995).
O algoritmo subseqüente demonstra os passos que devem ser seguidos para transformar um
Autômato Finito Determinístico para um Autômato Finito Determinístico Mínimo.
Algoritmo de transformação de um Autômato Finito Determinístico para um Autômato Finito
Determinístico Mínimo
ENTRADA: um AFD M = (Q, Σ, δ, q0, F);
SAÍDA: um AFDm M’ = (Q’, Σ’, δ’, q0’, F’), tal que M’ ≡ M
passo 1. eliminação dos estados inacessíveis
1. assinalar inicialmente o estado inicial como estado acessível;
2. para cada estado qi assinalado, marcar os estados qj alcançáveis por uma transição
x partir de qi ;
3. eliminar os estados que não foram assinalados.
passo 2. eliminação das transições indefinidas
1. incluir um novo estado não-final Φ, onde são colocadas transições para ele mesmo
com todos os símbolos do alfabeto;
2. com a inclusão do novo estado não-final Φ, as transições não previstas são
trocadas por uma transição para este novo estado não-final.
passo 3. determinação dos estados equivalentes
34
1. dividir Q em duas classes de equivalência, a primeira contendo os estados finais e
a segunda contendo os demais estados de Q;
2. realizar sucessivas divisões nas classes obtidas até nenhuma nova classe seja
obtida. É necessário considerar nesse passo que um conjunto de estados q0, q1, ...,
qn está na mesma classe de equivalência se todas as transições que partem destes
estados levam o Autômato aos estados qi, qi+1, ..., qn estando estes em uma mesma
classe equivalente também.
passo 4. eliminação dos estados mortos
1. assinalar inicialmente os estados finais como não mortos;
2. assinalar os estados qj que alcançam um estado assinalado qi;
3. eliminar os estados que não foram assinalados, tornando indefinidas as transições
que levam a um estado eliminado.
passo 5. construção do Autômato Finito Determinístico Mínimo M’ = (Q’, Σ’, δ’, e0’, F’), onde:
Q’ - conjunto finito de estados equivalentes;
∑’ - alfabeto de símbolos de entrada, tal que Σ’ = Σ;
δ' - função de transição: Q’ x ∑’ → Q’, tal que δ' ({p}, x) = {q} ↔ δ(pi, x) = qi,
sendo pi e qi são elementos de {p} e {q}, respectivamente, e {p} e {q} são
conjuntos de estados equivalentes;
q0’- estado equivalente que contém o estado inicial q0;
F’ - conjunto de estados equivalentes (F’ ⊆ Q’), tal que algum estado
componente de F’ é um estado final de M.
Exemplo de transformação de um Autômato Finito Determinístico para um Autômato Finito
Determinístico Mínimo
Considerando o Autômato Finito Determinístico da Figura 14
35
a
a
a
b
bc
a, b
a, b a, b, c
início q0 q1
q4
q3
q2
q5
Figura 14: Diagrama de transição do Autômato Finito Determinístico
e aplicando o algoritmo de minimização de Autômatos Finitos.
passo 1. eliminação dos estados inacessíveis (Figura 15).
δ a b c acessíveis
→ q0 q1 - - X
* q1 q2 q3 q5 X
* q2 q2 q2 - X
* q3 q3 q3 - X
* q4 q4 q1 -
q5 q5 q5 q5 X Figura 15: Tabela de transição do Autômato Finito Determinístico com identificação dos estados
acessíveis
A tabela de transição do Autômato Finito Determinístico resultante da eliminação dos estados
inacessíveis pode ser observada na Figura 16.
36
δ a b c
→ q0 q1 - -
* q1 q2 q3 q5
* q2 q2 q2 -
* q3 q3 q3 -
q5 q5 q5 q5
Figura 16: Tabela de transição do Autômato Finito Determinístico sem os estados inacessíveis
passo 2. eliminação das transições indefinidas.
As transições δ (q0, b), δ (q0, c), δ (q2, c) e δ (q3, c) são indefinidas; e portanto, eliminar tais
transições implica em adicionar ao Autômato Finito Determinístico um novo estado não final Φ e
substituir as transições indefinidas por transições para Φ e estabelecer transições de Φ para Φ
com todos os símbolos do alfabeto.
A Figura 17 demonstra a eliminação das transições indefinidas para o Autômato Finito
Determinístico.
δ a b c
→ q0 q1 Φ Φ
* q1 q2 q3 q5
* q2 q2 q2 Φ
* q3 q3 q3 Φ
q5 q5 q5 q5
Φ Φ Φ Φ Figura 17: Tabela de transição do Autômato Finito Determinístico sem transições indefinidas
passo 3. determinação dos estados equivalentes.
Para determinar os estados equivalentes é necessária a construção dos conjuntos de equivalência.
37
iteração 0
Inicialmente, dois conjuntos de equivalência são gerados, os dos estados finais e dos estados não-
finais (Figura 18).
iteração finais não-finais
0 {q1, q2, q3} {q0, q5, Φ} Figura 18: Tabela de equivalência de estados finais e não finais do Autômato Finito Determinístico
iteração 1
Na seqüência, dividir sucessivamente os conjuntos de equivalência até que nenhum novo
conjunto de equivalência seja obtido.
{q1, q2} δ (q1, a) = q2 δ (q1, b) = q3 δ (q1, c) = q5
δ (q2, a) = q2 δ (q2, b) = q2 δ (q2, c) = Φ
Como a relação de equivalência se manteve para todos os símbolos do alfabeto,
q1 e q2 continuam em um mesmo conjunto de equivalência.
{q1, q3} δ (q1, a) = q2 δ (q1, b) = q3 δ (q1, c) = q5
δ (q3, a) = q3 δ (q3, b) = q3 δ (q3, c) = Φ
Como a relação de equivalência se manteve para todos os símbolos do alfabeto,
q1 e q3 continuam em um mesmo conjunto de equivalência.
{q2, q3} como q1 é equivalente a q2 e q1 é equivalente a q3, q2 e q3 são equivalentes.
{q0, q5} δ (q0, a) = q1 δ (q0, b) = Φ δ (q0, c) = Φ
δ (q5, a) = q5 δ (q5, b) = q5 δ (q5, c) = q5
Como a relação de equivalência não se manteve, q0 e q5 não são equivalentes e, portanto, novos
conjuntos de equivalência deve ser formado com os estados q0 e q5.
{q0, Φ} δ (q0, a) = q1 δ (q0, b) = Φ δ (q0, c) = Φ
δ (Φ, a) = Φ δ (Φ, b) = Φ δ (Φ, c) = Φ
q0 e Φ não são equivalentes.
38
{q5, Φ} δ (q5, a) = q5 δ (q5, b) = q5 δ (q5, c) = q5
δ (Φ, a) = Φ δ (Φ, b) = Φ δ (Φ, c) = Φ
Como a relação de equivalência se manteve para todos os símbolos do alfabeto,
q5 e Φ continuam em um mesmo conjunto de equivalência.
Após a primeira iteração, os conjuntos de equivalência podem ser observados na Figura 19.
iteração finais não-finais
0 {q1, q2, q3} {q0, q5, Φ}
1 {q1, q2, q3} {q0} {q5, Φ} Figura 19: Tabela de conjuntos de equivalência (1° iteração)
iteração 2
{q1, q2} idem iteração 1
{q1, q3} idem iteração 1
{q2, q3} idem iteração 1
{q5, Φ} idem iteração 1
Após a segunda iteração, os conjuntos de equivalência podem ser observados na Figura 20.
iteração finais não-finais
0 {q1, q2, q3} {q0, q5, Φ}
1 {q1, q2, q3} {q0} {q5, Φ}
2 {q1, q2, q3} {q0} {q5, Φ} Figura 20: Tabela de conjuntos de equivalência (2° iteração)
Como nenhum novo conjunto de equivalência foi criado, o processo de construção dos conjuntos
de estados equivalentes é encerrado.
passo 4. eliminação dos estados mortos (Figura 21)
39
δ a b c
→ q0 q1 Φ Φ
* q1 q2 q3 q5
* q2 q2 q2 Φ
* q3 q3 q3 Φ
q5 q5 q5 q5
Φ Φ Φ Φ Figura 21: Tabela de transição do Autômato Finito Determinístico com identificação dos estados
não mortos
A tabela de transição do Autômato Finito Determinístico resultante da eliminação dos estados
mortos pode ser observada na Figura 22.
δ a b c
→ q0 q1 - -
* q1 q2 q3 q5
* q2 q2 q2 -
* q3 q3 q3 - Figura 22: Tabela de transição do Autômato Finito Determinístico sem estados mortos
passo 5. construção do Autômato Finito Determinístico Mínimo
Como q5 e Φ são estados mortos, o conjunto de equivalência {q5, Φ} deve ser desprezado.
Renomear os conjuntos de equivalência {q1, q2, q3} e {q0} para q0 e q1, respectivamente, e montar
a tabela de transição do Autômato Finito Determinístico Mínimo (Figura 23) ou o diagrama de
transição do Autômato Finito Determinístico Mínimo (Figura 24).
40
δ a b c
* q0 q0 q0 -
→ q1 q0 - - Figura 23: Tabela de transição do Autômato Finito Determinístico Mínimo
q0 q1 início a
a, b
Figura 24: Diagrama de transição do Autômato Finito Determinístico Mínimo
2.3 EXPRESSÃO REGULAR
Assim como o Autômato Finito, uma Expressão Regular tem a capacidade de representar uma
linguagem. No entanto, ao contrário dos Autômatos Finitos que são dispositivos reconhecedores
de sentenças, uma Expressão Regular é um formalismo denotacional de uma Linguagem Regular,
ou seja, uma forma declarativa de representar quais sentenças fazem parte da linguagem.
(MENEZES, 2002; HOPCROFT; ULLMAN; MOTWANI, 2002).
As Expressões Regulares são uma notação importante para especificar os padrões de formação de
sentenças. Em particular, apresentam grande utilidade na representação dos tokens de uma
linguagem de programação, os quais são reconhecidos na análise léxica através de Autômatos
Finitos construídos a partir de Expressões Regulares. Segundo PRICE; TOSCANI (2001), a
vantagem de se usar Expressões Regulares na especificação das unidades léxicas é a consistência
e clareza que esse formalismo oferece.
A definição de uma Expressão Regular é feita a partir de conjuntos e suas operações de
concatenação, união e fechamento. (MENEZES, 2002; HOPCROFT; ULLMAN; MOTWANI,
2002).
41
união: dadas duas linguagens L1 = {0, 1, 01, 11} e L2 = {ε, 11}, a união de L1 e L2,
denotada por L1 ∪ L2, é o conjunto de sentenças que estão em L1 ou em L2 ou em ambas,
ou seja, L1 ∪ L2 = {ε, 0, 01, 10, 11};
concatenação: a concatenação de duas linguagens L1 e L2, denotada por L1L2, é o
conjunto de qualquer sentença de L1 concatenada com qualquer sentença de L2. Para L1 =
{0, 1, 01, 11} e L2 = {ε, 11}, a concatenação das duas linguagens é dada por L1L2 =
{0, 1, 01, 11, 011, 111, 0111, 1111}, onde as quatro primeiras sentenças são resultantes
da concatenação das sentenças L1 com a sentença ε de L2 (ε é a sentença vazia, de
comprimento13 zero e identidade na concatenação) e as quatro sentenças seguintes são
obtidas da concatenação das sentenças de L1 com a sentença 11 de L2;
fechamento14: para uma linguagem L, o fechamento de L, denotado por L* é o conjunto
de todas as sentenças que podem ser produzidas com a concatenação de um número
qualquer de sentenças de L. Para L = {0, 1}, L* = {ε, 0, 1, 00, 01, 10, 11, 000, 001...}, ou
seja, todas as sentenças de 0’s e 1’s e ainda a sentença ε.
Para que uma Expressão Regular seja definida sobre um alfabeto é necessário estabelecer um
conjunto de regras: (MENEZES, 2002; AHO; SETHI; ULLMAN, 1995).
Ø é uma Expressão Regular que denota a linguagem vazia;
ε é uma Expressão Regular que denota a linguagem que contém somente a sentença vazia,
ou seja, {ε};
para cada símbolo r pertencente ao alfabeto R, r é uma Expressão Regular que denota a
linguagem unitária contendo a sentença r, ou seja, o conjunto {r};
r e s são Expressões Regulares que denotam as linguagens R e S, respectivamente, então:
a) r | s é uma Expressão Regular que denota a linguagem dada por R ∪ S
(união);
b) rs é uma Expressão Regular que denota a linguagem dada por RS
(concatenação);
13 O comprimento ou tamanho de uma sentença corresponde ao número de símbolos da sentença. 14 Também chamado de estrela ou fechamento de Kleene.
42
c) r* é uma Expressão Regular que denota a linguagem dada por R*
(concatenação sucessiva);
d) r é uma Expressão Regular que denota a linguagem dada por R.
Na construção de Expressões Regulares é possível fazer o pleno uso de parênteses para
estabelecer a prioridade das operações. No entanto, muitos parênteses podem ser suprimidos se
for assumido que o símbolo * (concatenação sucessiva) tem maior precedência que a
concatenação e que a concatenação tem maior precedência que a união. (AHO; SETHI;
ULLMAN, 1995; MENEZES, 2002).
Assim, a Expressão Regular ((0 (1)* ) | 0), que denota a linguagem cujas sentenças começam com
um 0 seguido por qualquer quantidade de 1’s, pode ser simplificada para 01* | 0.
“As Expressões Regulares podem ser usadas para denotar somente um número fixo de repetições
ou um número não especificado de repetições de uma dada construção”. (AHO; SETHI;
ULLMAN, 1995, p.45).
2.3.1 Propriedades das Expressões Regulares
Segundo AHO; SETHI; ULLMAN (1995) duas Expressões Regulares podem ser equivalentes,
ou seja, denotar a mesma linguagem. Ainda, AHO; SETHI; ULLMAN (1995) apresentam leis
algébricas para manipular Expressões Regulares em formas equivalentes, conforme a Figura 25.
AXIOMA DESCRIÇÃO r | s = s | r a união é comutativar | (s | t) = (r | s) | t a união é associativa(rs)t = r(st) a concatenação é associativar(s | t) = rs | rt ^
(s | t)r = sr | tr
a concatenação se distribui sobre a união
εr = r ^ rε = r ε é o elemento neutro da concatenaçãor* = (r | ε)* relação entre ε e * (concatenação sucessiva) r** = r * a concatenação sucessiva é idempotente
Figura 25: Leis algébricas das Expressões Regulares Fonte: (AHO; SETHI; ULLMAN, 1995)
2.3.2 Simplificação de Expressões Regulares
Existem algumas construções que aparecem muitas vezes nas Expressões Regulares e por isso
foram introduzidas algumas simplificações notacionais para facilitar a elaboração de Expressões
43
Regulares. Uma destas simplificações é dada pelo símbolo + (adição), que significa uma ou mais
ocorrências de, e a outra pelo símbolo ? (interrogação), que significa uma ou nenhuma
ocorrência de. (AHO; SETHI; ULLMAN, 1995).
Assim,
(0 | ... | 9)+ significa toda sentença com um ou mais dígitos;
(0 | ... | 9)? significa toda sentença com nenhum ou apenas um dígito;
(0 | ... | 9)* significa toda sentença com nenhum, um ou mais dígitos.
2.3.3 Definição Regular
É possível atribuir nomes às Expressões Regulares, assim como definir outras Expressões
Regulares utilizando os nomes como símbolos. Assim, para um alfabeto V, uma definição
regular é uma seqüência de definições da seguinte forma:
d1 ⇒ r1
d2 ⇒ r2
...
dn ⇒ rn
onde cada di é um nome e cada ri uma expressão sobre os símbolos em V ∪ { d1, d2 ... dn - 1}, isto
é os símbolos do alfabeto V e os nomes anteriormente definidos. (AHO; SETHI; ULLMAN,
1995).
A seqüência de definições regulares
letra → A | … | Z | a | … | z
dígito → 0 | … | 9
identificador_PASCAL → letra (letra | dígito | _)*
44
descrevem o padrão de formação do token identificador na linguagem de programação
PASCAL15.
2.4 AUTÔMATO FINITO X EXPRESSÃO REGULAR
Apesar de a abordagem de Autômatos Finitos – formalismo usado no reconhecimento de
sentenças – ser fundamentalmente diferente da abordagem de Expressões Regulares – mecanismo
denotacional e gerador de sentenças – ambos representam a mesma classe de linguagens, a
Linguagem Regular.
Determinadas situações podem exigir que seja encontrada a Expressão Regular que descreve a
linguagem aceita por um Autômato Finito ou que a partir de uma Expressão Regular qualquer
seja construído o Autômato Finito correspondente.
2.4.1 Conversão de Expressões Regulares em Autômatos Finitos
Expressões Regulares podem ser convertidas em Autômatos Finitos Não-Determinísticos com
Movimento Vazio através da aplicação do Algoritmo de Thompson, o qual se orienta pela
estrutura da Expressão Regular para construir o Autômato Finito correspondente. Inicialmente
são construídos Autômatos Finitos que reconheçam ε e os símbolos do alfabeto. Na seqüência,
Autômatos Finitos para as operações de união, concatenação e fechamento são elaborados. À
medida que se avança no processo de construção, cada passo introduz ao menos dois novos
estados no Autômato Finito. Consequentemente, o Autômato Finito Não-Determinístico com
Movimento Vazio obtido terá no máximo o dobro do número de símbolos e de operadores da
Expressão Regular.
Algoritmo para conversão de uma Expressão Regular em um Autômato Finito (Algoritmo de
Thompson)
ENTRADA: uma Expressão Regular r sobre um alfabeto Σ.
SAÍDA: um Autômato Finito Não-Determinístico com Movimento Vazio que reconhece a
linguagem denotada r.
15 Em PASCAL, os identificadores iniciam com uma letra, seguida por qualquer quantidade de letras, dígitos ou underlines, em qualquer ordem.
45
passo 1. decompor r em expressões constituintes (símbolos do alfabeto, união, concatenação e
fechamento).
passo 2. construir os Autômatos Finitos para cada relação elementar pela aplicação das regras:
a) para ε, o Autômato Finito Não-Determinístico com Movimento Vazio
(Figura 26).
início εq0 q1
Figura 26: Autômato Finito Não-Determinístico com Movimento Vazio com
transição ε
b) para ∀ x ∈ Σ, o Autômato Finito Não-Determinístico com Movimento
Vazio (Figura 27).
início aq0 q1
Figura 27: Autômato Finito Não-Determinístico com Movimento Vazio com
transição
c) sejam r1 e r2 Expressões Regulares e AFN-ε (r1) e AFN-ε (r2) Autômatos
Finitos Não-Determinísticos com Movimento Vazio r1 e r2 com operações:
• para a operação de união de r1 e r2 (r1 | r2), o Autômato Finito Não-
Determinístico com Movimento Vazio (Figura 28).
46
inícioAFN-ε (r1)
AFN-ε (r2)
q0 q1
ε
ε ε
ε
Figura 28: Autômato Finito Não-Determinístico com Movimento Vazio
resultante da união
(existe uma transição ε a partir de qi para os estados iniciais de AFN-ε (r1) e
AFN-ε (r2), assim como uma transição ε a partir dos estados finais de AFN-
ε (r1) e AFN-ε (r2) para o estado qf).
• para a operação de concatenação de r1 e r2 (r1r2), Autômato Finito
Não-Determinístico com Movimento Vazio (Figura 29).
q0 q1
AFN-ε (r1) AFN-ε (r2)
início
Figura 29: Autômato Finito Não-Determinístico com Movimento Vazio
resultante da concatenação
(o estado inicial do AFN-ε (r1) e o estado final de AFN-ε (r2) se tornam,
respectivamente, os estados inicial e final do Autômato Finito Não-
Determinístico com Movimento Vazio resultante).
• para a operação de fechamento de r (r*), o Autômato Finito Não-
Determinístico com Movimento Vazio (Figura 30).
47
inícioAFN-ε (r)
q0 q1 ε ε
ε
ε
Figura 30: Autômato Finito Não-Determinístico com Movimento Vazio
resultante do fechamento
Exemplo de conversão de uma Expressão Regular para um Autômato Finito
Seja a Expressão Regular (a | b)* a,
passo 1. r1 = a
r2 = b
r3 = r1 | r2
r4 = r3*
r5 = r4 r1
passo 2.
• para r1 (Figura 31)
inícioq2 q3
a
Figura 31: Autômato Finito para reconhecer a
48
• para r2 (Figura 32)
inícioq4 q5
b
Figura 32: Autômato Finito para reconhecer b
• para r3 (Figura 33)
inícioq1
q2 q3
q4 q5
q6
ε
ε
ε
ε
a
b
Figura 33: Autômato Finito Não-Determinístico com Movimento Vazio para reconhecer a | b
49
• para r4 (Figura 34)
inícioq1
q2 q3
q4 q5
q6
ε
ε
ε
ε
a
b
εq0 q7
ε
ε
ε
Figura 34: Autômato Finito Não-Determinístico com Movimento Vazio para reconhecer (a | b)*
• para r5 (Figura 35)
inícioq1
q2 q3
q4 q5
q6
ε
ε
ε
ε
a
b
εq0
q7 ε
ε
aq8
ε
Figura 35: Autômato Finito Não-Determinístico com Movimento Vazio para reconhecer (a | b)* a
50
2.4.2 Conversão de Autômatos Finitos em Expressões Regulares
Segundo HOPCROFT; ULLMAN; MOTWANI (2002), a construção de Expressões Regulares a
partir de um Autômato Finito é significativamente complexa. De forma geral, são construídas
expressões que descrevem conjuntos de sentenças que identificam determinados caminhos no
Autômato Finito representado através de um diagrama de transição. A princípio somente e
permite que os caminhos sejam formados por um conjunto limitado de estados. Indutivamente se
inicia com expressões mais simples as quais descrevem caminhos que não podem ser compostos
por quaisquer estados e se constrói as expressões que permitem a passagem dos caminhos por
conjunto de estados progressivamente maiores. Então, é admitido que os caminhos possam passar
por quaisquer estados e, com isto, as expressões geradas representam todos os possíveis caminhos
do Autômato Finito.
2.4.3 Aplicações de Autômatos Finitos e Expressões Regulares
As Expressões Regulares e os Autômatos Finitos são dispositivos formais simples, mas que
apresentam um grande poder de representação. Em particular, a utilização desses formalismos no
desenvolvimento de aplicações computacionais possibilita a produção de sistemas mais
eficientes.
As unidades léxicas de uma linguagem de programação podem ser especificadas através de
Expressões Regulares, as quais podem ser convertidas para Autômatos Finitos equivalentes. Os
Autômatos Finitos são então usados na implementação do analisador léxico. A geração
automática de analisadores léxicos também pode ser feita a partir da especificação das
Expressões Regulares que representam o padrão de formação dos tokens.
Autômatos Finitos e Expressões Regulares têm sido amplamente utilizados em sistemas de
recuperação de textos, linguagens de consulta de banco de dados e de processamento de arquivos.
A busca e substituição de seqüências de caracteres em editores de texto podem ser eficientemente
realizadas se tais seqüências forem representadas por Expressões Regulares e a operação
realizada em termos de um Autômato Finito. Muitos editores de texto como vi, emacs e
programas como grep e egrep do UNIX e linguagens de programação como AWK, PERL e SED
fazem uso destes formalismos.
51
Especificação de protocolos de comunicação, segurança de arquivos, modelagem de redes neurais
e compressão de dados são também possibilidades de uso das Expressões Regulares e Autômatos
Finitos.
52
3 DESENVOLVIMENTO DO SOFTWARE
A partir dos assuntos abordados anteriormente, pode-se obter o conhecimento necessário para o
desenvolvimento do software. Para este desenvolvimento foi seguida a seguinte seqüência:
Modelagem do software (desenvolvimento de casos de uso, diagramas de seqüência e
classe);
Implementação do software (implementar o software seguindo o que foi desenvolvido na
modelagem);
Testes do software (testar o software para encontrar possíveis erros).
3.1 MODELAGEM
Para o desenvolvimento da especificação deste software foi utilizada a linguagem de modelagem
UML (Unified Modeling Language) e como ambiente desta modelagem foi utilizado o EA
(Enterprise Architect).
A seguir serão mostrados os principais casos de uso e diagramas de seqüência da aplicação, assim
como o seu diagrama de classe, todos desenvolvidos com a ferramenta acima mencionada.
3.1.1 Casos de Uso
Um caso de uso descreve um cenário de uma possível interação, podendo ser com um utilizador
ou um outro sistema. Cada caso de uso deve descrever somente uma funcionalidade ou objetivo
do sistema.
Na sequência (Figuras 36 a 43) estão descritos os diagramas de caso de uso: Desenhar Automato,
Imprimir, Reconhecer Direto, Reconhecer Passo a Passo, Tipo de Automato, Converte AFN-ε
para AFN, Converte AFN para AFD e Converte AFD para AFDm.
53
ud Desenhar Automato
EA 5.0 Unregistered Trial Version EA 5.
EA 5.0 Unregistered Trial Version EA 5.
EA 5.0 Unregistered Trial Version EA 5.
EA 5.0 Unregistered Trial Version EA 5.
EA 5.0 Unregistered Trial Version EA 5.Usuario
Desenhar Automato
Name:Package:Version:Author:
Desenhar AutomatoDiagrama Caso de Uso Desenhar Automato1.0
Caso de Uso Desenhar Autômato
Breve Descrição Com uma janela do editor aberta o usuário desenhará o autômato
desejado inserindo primeiramente o estado inicial seguido de qualquer
número de estados intermediários. Para tornar um estado em estado final
basta dar dois clicks com o botão esquerdo do mouse em cima do estado
desejado.
Para desenhar a transição é preciso selecionar o estado origem e o estado
destino.
Ator (es) Usuário
Pré-condições
Fluxo Principal 1. O usuário irá abrir uma nova janela no editor.
2. Para construir o autômato, o usuário deverá obrigatoriamente criar
primeiro o estado inicial.
3. Após iniciar o autômato com um estado inicial o usuário poderá
adicionar quantos estados desejar.
4. Se desejar tornar o estado em um estado final, é preciso dar um duplo
clique no estado selecionado.
5. Para criar uma transição, e necessário selecionar dois estados (origem
e destino). Caso a transição seja para o mesmo estado, basta apenas
este estado estar selecionado. Com isso abrirá uma janela solicitando
o símbolo para transição.
54
Fluxo Alternativo 2.1. Caso não inicie com um estado inicial, o sistema retornará uma msg,
que para iniciar é preciso ser um estado inicial.
Pós-Condições
Figura 36: Caso de Uso Desenhar Autômato
ud Imprimir
EA 5.0 Unregistered Trial Version EA 5
EA 5.0 Unregistered Trial Version EA 5
EA 5.0 Unregistered Trial Version EA 5
EA 5.0 Unregistered Trial Version EA 5
EA 5.0 Unregistered Trial Version EA 5Usuario
Imprimir
Name:Package:Version:Author:
ImprimirDiagrama Caso de Uso Imprimir1.0
Caso de Uso Imprimir
Breve Descrição Após desenhado o autômato desejado, para imprimi-lo basta pressionar o
botão imprimir.
Ator (es) Usuário
Pré-condições Para imprimir deverá obrigatoriamente ter um autômato desenhado
Fluxo Principal 1. Após desenhado o autômato basta clicar no botão imprimir.
2. O editor envia o autômato para impressora local.
Fluxo Alternativo 1.1. Caso não exista um autômato no editor, o sistema retornara uma
msg, que não existe autômato para imprimir.
Pós-Condições
Figura 37: Caso de Uso Imprimir
55
ud Diagrama Caso de Uso Reconhecer Direto
EA 5.0 Unregistered Trial Version EA 5.0 Unre
EA 5.0 Unregistered Trial Version EA 5.0 Unre
EA 5.0 Unregistered Trial Version EA 5.0 Unre
EA 5.0 Unregistered Trial Version EA 5.0 UnreUsuario
Direto
Name:Package:Version:Author:
Diagrama Caso de Uso Reconhecer DiretoDiagrama Caso de Uso Reconhecer Direto1.0
Caso de Uso Reconhecer Direto
Breve Descrição Com o autômato desenhado e a sentença digitada o usuário pressionará a
opção reconhecer a sentença de forma direta, esta analisara a sentença
digitada retornando se a sentença é reconhecida ou não pelo autômato.
Ator (es) Usuário
Pré-condições Existir um autômato no editor e uma sentença para ser analisada
Fluxo Principal 1. O usuário irá digitar uma palavra no campo digite a sentença.
2. O usuário irá selecionar no menu reconhecer a opção que permite
fazer o reconhecimento da palavra diretamente.
3. O editor retornará uma mensagem indicando se a palavra foi aceita ou
rejeitada.
Fluxo Alternativo 1.1. Caso não tenha digitado a sentença no campo o sistema retornara
uma msg, que não existe sentença para analisar.
Pós-Condições
Figura 38: Caso de Uso Reconhecer Direto
56
ud Diagrama Caso de Uso Reconhecer Passo
EA 5.0 Unregistered Trial Version EA 5.0 Unregis
EA 5.0 Unregistered Trial Version EA 5.0 Unregis
EA 5.0 Unregistered Trial Version EA 5.0 Unregis
EA 5.0 Unregistered Trial Version EA 5.0 UnregisUsuario
Passo a Passo
Name:Package:Version:Author:
Diagrama Caso de Uso Reconhecer PassoDiagrama Caso de Uso Reconhecer Passo1.0
Caso de Uso Reconhecer Passo a Passo
Breve Descrição Com o autômato desenhado e a sentença digitada o usuário pressionará a
opção reconhece a sentença passo a passo, ou seja, será analisada a
sentença digitada mostrando o caminho que esta percorre no autômato.
Ator (es) Usuário
Pré-condições Existir um autômato no editor e uma sentença para ser analisada
Fluxo Principal 1. O usuário irá digitar uma palavra no campo digite a sentença.
2. O usuário irá selecionar no menu reconhecer a opção que permite
fazer o reconhecimento da palavra passo a passo.
3. O editor retornará uma mensagem indicando se a palavra foi aceita ou
rejeitada e apresentará o caminho percorrido no reconhecimento.
Fluxo Alternativo 1.1. Caso não tenha digitado a sentença no campo o sistema retornará
uma msg, que não existe sentença para analisar.
Pós-Condições
Figura 39: Caso de Uso Reconhecer Passo a Passo
57
ud Tipo de Automato
EA 5.0 Unregistered Trial Version EA 5.0 U
EA 5.0 Unregistered Trial Version EA 5.0 U
EA 5.0 Unregistered Trial Version EA 5.0 U
EA 5.0 Unregistered Trial Version EA 5.0 U
EA 5 0 Unregistered Trial Version EA 5 0 UUsuario
Tipo de Automato
Name:Package:Version:Author:
Tipo de AutomatoDiagrama Caso de Uso Tipo Automato1.0
Caso de Uso Tipo de Autômato
Breve Descrição Com o autômato devidamente desenhado o usuário verifica se o
autômato é um AFD, AFN ou AFN-ε com base nas suas propriedades
verificadas na tabela de transição.
Ator (es) Usuário
Pré-condições Existir um autômato qualquer no editor
Fluxo Principal 1. O usuário irá selecionar no menu reconhecer a opção tipo autômato
que permite fazer o reconhecimento do autômato especificado.
2. O editor irá determinar o tipo do autômato finito.
3. O editor apresentará uma mensagem com o tipo de autômato.
Fluxo Alternativo 1.1. Se não possuir autômato no editor o sistema retorná uma msg
dizendo que não possui autômato para verificação
Pós-Condições
Figura 40: Caso de Uso Tipo de Autômato
58
ud Diagrama Caso de Uso Conv erte Automato AFNE para AFN
EA 5.0 Unregistered Trial Version EA 5.0 Unregi
EA 5.0 Unregistered Trial Version EA 5.0 Unregi
EA 5.0 Unregistered Trial Version EA 5.0 Unregi
EA 5.0 Unregistered Trial Version EA 5.0 UnregiUsuario
AFNEparaAFN
Name:Package:Version:Author:
Diagrama Caso de Uso Converte Automato AFNE para AFNDiagrama Caso de Uso Converte Automato AFNE para AFN1.0
Caso de Uso Converte AFNE para AFN
Breve Descrição Com o autômato desenhado e este sendo AFN-ε é realizada a
transformação do autômato finito não determinístico com movimento
vazio em um autômato finito não determinístico seguindo seu algoritmo
de conversão.
Ator (es) Usuário
Pré-condições Existir um autômato no editor e este ser um AFN-ε
Fluxo Principal 1. O usuário irá desenhar o autômato desejado para conversão.
2. O usuário clica no menu converter o botão AFNeParaAFN.
3. O editor converte o autômato e o imprime na tela.
Fluxo Alternativo 2.1. Caso não exista um autômato desenhado, o sistema retornará uma
msg, indicando que não existe autômato para conversão.
Pós-Condições
Figura 41: Caso de Uso Converte AFNE para AFN
59
ud Diagrama Caso de Uso Conv erte Automato AFN para AFD
EA 5.0 Unregistered Trial Version EA 5.0 Unregi
EA 5.0 Unregistered Trial Version EA 5.0 Unregi
EA 5.0 Unregistered Trial Version EA 5.0 Unregi
EA 5.0 Unregistered Trial Version EA 5.0 UnregiUsuario
AFNparaAFD
Name:Package:Version:Author:
Diagrama Caso de Uso Converte Automato AFN para AFDDiagrama Caso de Uso Converte Automato AFN para AFD1.0
Caso de Uso Converte AFN para AFD
Breve Descrição Com o autômato desenhado e este sendo AFN é realizada a
transformação do autômato finito não determinístico em um autômato
finito determinístico seguindo seu algoritmo de conversão.
Ator (es) Usuário
Pré-condições Existir um autômato no editor e este ser um AFN
Fluxo Principal 1. O usuário irá desenhar o autômato desejado para conversão.
2. O usuário clica no menu converter o botão AFNparaAFD.
3. O editor converte o autômato e o imprime na tela.
Fluxo Alternativo 2.1. Caso não exista um autômato desenhado, o sistema retornará uma
msg, indicando que não existe autômato para conversão.
Pós-Condições
Figura 42: Caso de Uso Converte AFN para AFD
60
ud Diagrama Caso de Uso Conv erte Automato AFD para AFDM
EA 5.0 Unregistered Trial Version EA 5.0 Unregist
EA 5.0 Unregistered Trial Version EA 5.0 Unregist
EA 5.0 Unregistered Trial Version EA 5.0 Unregist
EA 5.0 Unregistered Trial Version EA 5.0 UnregistUsuario
AFDparaAFDM
Name:Package:Version:Author:
Diagrama Caso de Uso Converte Automato AFD para AFDMDiagrama Caso de Uso Converte Automato AFD para AFDM1.0
Caso de Uso Converte AFD para AFDM
Breve Descrição Com o autômato desenhado e este sendo AFD é realizada a
transformação Transforma um autômato finito determinístico em um
autômato finito determinístico mínimo seguindo seu algoritmo de
conversão.
Ator (es) Usuário
Pré-condições Existir um autômato no editor e este ser um AFD
Fluxo Principal 1. O usuário irá desenhar o autômato desejado para conversão.
2. O usuário clica no menu converter o botão AFDparaAFDM.
3. O editor converte o autômato e o imprime na tela.
Fluxo Alternativo 2.1. Caso não exista um autômato desenhado, o sistema retornará uma
msg, indicando que não existe autômato para conversão.
Pós-Condições
Figura 43: Caso de Uso Converte AFD para AFDM
3.1.2 Diagramas de Seqüência
Um diagrama de sequência representa a sequência de processos (mais especificamente, de
mensagens passadas entre objetos) num programa de computador. Objetos representam as
instâncias das classes no processo, sendo ilustrados por meio de retângulos.
61
A seguir são apresentadas (Figuras 44 a 47) os diagramas de sequência Imprimir, Converter
Automato, Reconhecer e Tipo de Automato.
sd Imprimir
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
Figura 44: Diagrama de Seqüência Imprimir
sd Converter Automato
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5 0 Unregistered Trial Version EA 5 0 Unregistered Trial Version EA 5 0
Usuario
EditorAf TAf
alt
[se AFNe faca]
[se AFN faca]
[se AFD faca]
Solicita verificacao
Verifica automato
AFNEparaAFN()
AFNparaAFD
AFDparaAFDM
Retorna a conversao escolhida na tela
Name:Package:Version:Author:
Converter AutomatoDiagrama de Sequencia Converter Automato1.0
Figura 45: Diagrama de Seqüência Converter Autômato
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0
Usuario
EditorAf TAf
Name:Package:Version:Author:
ImprimirDiagrama de Sequencia Imprimir1.0
Solicita verificacao
Verifica automato
Imprimir()
Retorna documento impresso na impressora local
62
sd Diagrama de Sequencia Reconhecer
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5 0 Unregistered Trial Version EA 5 0 Unregistered Trial Version EA 5 0 Unreg
Usuario
EditorAf TAf
Confirmar sentenca
Reconhecer(sentenca,result)
Aceitacao(result = false)
Aceitacao(result = true)
Aceita ou Nao aceita
Name:Package:Version:Author:
Diagrama de Sequencia ReconhecerDiagrama de Sequencia Reconhecer1.0
Figura 46: Diagrama de Seqüência Reconhecer
sd Tipo Automato
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unreg
Usuario
EditorAf TAf
Solicita verificacao
Verifica automato
TipoAutomato()
Retorna tipo do automato
Name:Package:Version:Author:
Tipo AutomatoDiagrama de Sequencia Tipo Automato1.0
Figura 47: Diagrama de Seqüência Tipo Autômato
63
3.1.3 Diagrama de Classe
O diagrama de classe é uma representação da estrutura e relações das classes que servem de
modelo para objetos. É muito útil para o sistema, definindo todas as classes que o sistema
necessita possuir e é a base para a construção dos diagramas de sequência e estados. A Figura 48
ilustra o diagrama de aplicação do software.
64
cd CLASSE
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version EA 5.0 Unregistered Trial Version
TConj
+ elementos: TList;
+ constructor Create()+ destructor Destroy; override;()
TAf
+ estados: TConj;+ alfabeto: TConj;+ estFinal: TConj;+ esInicial: TDesenha;+ transicao: TConj;+ Automato: TAutomato;- Finais: TStringList;- Inicial: String;
+ function TpAutomatoDet() : boolean+ function TpAutomatoAFNDe() : boolean+ function ComparaSimb(simb, simbLido : string)() : boolean+ procedure Reconstruir()+ constructor Create()+ destructor Destroy; override()+ function Aceitacao(sentenca, estado : string; pos: byte; passo : boolean = false)() : boolean+ procedure GeraAutomato()+ function LinhaEstado(estadoP : string; aut: TAutomato)() : int+ function ColunaAlfab(sentencaP : string; aut: TAutomato)() : int+ function TransicaoAut(estado, sentenca : string; aut: TAutomato)() : string+ procedure ListaEstados(estado : string; var listastring : TStringList)()+ function concatenaEstados(est1, est2 : string)() : string+ function EhEstadoFinal(aut : TAutomato; est : string)() : boolean+ procedure GeraLista(aut : TAutomato)()+ function GeraTransVazio(transVazio : string; LinhaEstado: integer; simbolo : string)() : string+ function PossuiTransVazio(estadoTranVazio : string)() : string+ function EstadosIguais(estado1, estado2: string)() : boolean+ procedure SinalizaEstadosAlcancaveis(var aut: TAutomato)()+ procedure SinalizaEstadosVivos(var aut: TAutomato)()+ procedure SinalizaEstadosMortos(var aut:TAutomato)() : void+ procedure CriaNovasClasses(equi: TStringList; equiLinha: integer; min : TAutomato; var aux: TStringList; var auxLinha: integer)() : void+ function GeraAutomatoMinimo(min: TAutomato; aux: TStringList; auxlinha:integer)() : TAutomato+ function Determiniza()() : TAutomato+ function Minimiza()() : TAutomato+ function ConverteAutomatoMovVazio()() : TAutomato+ procedure GeraTransicoes(var transicoes: TConj)()+ function BuscaAlfabeto(estado, simb: string)() : TDesenhaLinha
TTransicao
+ estadoAtual: string;+ simbolo: string;+ pEstado: string;
TDesenha
MAFI
+ estadoInicial: TDesenha+ estSelInicial: TDesenha+ estSelFinal: TDesenha- estados: TList+ Af: TAf- currentLeft: int- transicoes: TList- countEstados: int- currentTop: int- estadoExtremo: boolean
+ procedure Imprimir() : void+ procedure Sobre() : void+ procedure CriarMDIChild(const Name : string)() : void+ procedure FormCreate(Sender : TObject)() : void+ procedure FormDestroy(Sender : TObject)() : void+ procedure FormClose(Sender: TObject; var Action: TCloseAction)() : void+ procedure TipoAutomato() : void+ procedure DoisClicks(Sender : TObject)() : void+ procedure Atualizar(Sender : TDesenha)() : void+ procedure EditorAf(Sender : TObject)() : void+ procedure ReconhecerPasso() : void+ procedure ReconhecerDireto() : void+ procedure AFNEtoAFN() : void+ procedure AFNtoAFD() : void+ procedure AFDtoAFDM() : void+ procedure MostraAutomatoConvertido()- function BuscaEstado(estado: string)() : TDesenha- function BuscaEstado(estado: string)() : TDesenhaLinha- procedure DesenhaEstado(estado: string; inicial: boolean; final: boolean)()- procedure DesenhaTransicao(origem, destino: TDesenha; simbolo: string)() : void- procedure MostraTabAutomatoConv(aut: TAutomato; deterministico: boolean)()+ procedure DesenhaAutomato(aut: TAutomato; deterministico: boolean)()+ procedure MostraAutomatoConvertido()+ procedure MostraMatrizAutomato(aut: TAutomato)()+ procedure DesenhaAutomatoConvertido(aut: TAutomato; caption: string; deterministico: boolean)()
TForm
+ Form1: TForm1+ Form2: TForm2+ FormSobre: TFormSobre+ FormExibeAutomato: TFormExibeAutomato+ FormSplash: TFormSplash
1
1
1
1
Name:Package:Version:Author:
CLASSEDiagrama de Classes1.0
1
1
1
1
Figura 48: Diagrama de Aplicação do Software
65
3.2 IMPLEMENTAÇÃO
A implementação deste trabalho foi realizada na plataforma Windows Xp, com um computador
Celeron M de 1.7 Ghz com 512 Mb de memória e a linguagem de programação escolhida foi o
Object Pascal, no ambiente de programação da Borland Delphi 7, em razão do conhecimento do
autor nesta linguagem e sua familiaridade com a ferramenta. Outro fator para a escolha da
referida linguagem foi o conhecimento e experiência do orientador para com a mesma. Num
primeiro momento não foi planejado para o software o funcionamento em rede, sendo necessário
instalá-lo em cada máquina para utilização.
Inicialmente foi construída uma interface gráfica que utilizou como base para sua elaboração os
componentes desenvolvidos por Morastoni (2002). Um destes componentes foi à criação de uma
aplicação MDI16 onde o usuário poderá, se quiser ou for necessário, abrir mais de uma janela ao
mesmo tempo e desenhar o autômato desejado. Para desenhar o autômato é necessário que o
usuário determine o estado inicial, caso contrário o sistema não permitirá a inclusão de qualquer
outro estado.
Incluído o primeiro estado, o usuário poderá inserir quantos estados desejar e quantas transições
estes estados possuírem. Para isso foi implementada a classe TAf com os atributos alfabeto,
estado inicial, estados, estados finais e transições os quais armazenam todos os dados de entrada
do diagrama de transição do autômato.
Depois de desenhado o autômato, as únicas alterações que podem ser realizadas são:
Mudança do símbolo da transição, que se realiza com dois cliques do mouse em cima da
seta (transição);
Alteração de um estado indeterminado para estado final ou de um estado final para um
estado indeterminado, que se realiza também dando dois cliques no botão esquerdo do
mouse, sobre o estado desejado.
Todas estas alterações são controladas pela classe TDesenha (MORASTONI,2002), da qual
foram usadas funções para desenhar e controlar as propriedades do diagrama de transição do
autômato.
16 É uma aplicação que permite a criação de vários formulários dentro de um formulário principal. É uma das formas mais comuns de interface para sistemas de informação.
66
O reconhecimento do tipo de autômato é realizado pelo procedimento TipoAutomato que
percorre a tabela de transição criada verificando as suas propriedades e retorna se este é um
Autômato Finito Não Determinístico com Movimento Vazio, um Autômato Finito Não
Determinístico ou um Autômato Finito Determinístico, de acordo com as suas definições
apresentadas no capítulo 2 (seções 2.2.1, 2.2.2 e 2.2.3) imprimindo o tipo reconhecido e sua
respectiva tabela de transição na tela inferior do sistema.
Com o devido autômato desenhado, pode-se verificar se uma sentença é aceita ou não pelo
mesmo. Esta verificação pode ser realizada pelo software de forma direta através do
procedimento ReconhecerDireto, que apenas verifica a sentença a ser reconhecida, retornando se
a mesma é aceita ou não. Já passo a passo, a sentença é reconhecida percorrendo o autômato e
mostrando o caminho percorrido até o reconhecimento ou não da sentença que se dá pelo método
ReconhecerPasso.
Neste trabalho também é possível realizar as conversões dos Autômatos Finitos conforme foram
descritas no capítulo 2, seções 2.2.5.1 e 2.2.5.2. Em um primeiro momento foi implementada a
conversão de um Autômato Finito Não Determinístico com Movimento Vazio para um Autômato
Finito Não Determinístico; para isso foi construída a função AFNEparaAFN. Esta função realiza
a conversão do AFN- ε para um AFN equivalente, e imprime a tabela de transição resultante da
conversão e seu diagrama de transição equivalente em uma nova janela do software. Seu código
fonte esta apresentado no Apêndice I deste trabalho.
Logo após o desenvolvimento dessa função, foi realizada a conversão para Autômato Finito Não
Determinístico, como proposto no trabalho. Para isso foi criado um procedimento chamado
AFNparaAFD que determiniza o autômato de entrada AFN seguindo o algoritmo genérico
“construção de conjuntos” descrito no capítulo 2. Seu retorno é a tabela de transição do AFD
assim como seu diagrama de transição. O código fonte deste procedimento também se encontra
no Apêndice deste trabalho.
Na seqüência das implementações das conversões foi implementado um procedimento para
minimização de AFDs. Este procedimento foi chamado de AFDparaAFDM, o qual chama a
função Minimiza implementada na classe TAf que segue os passos do algoritmo genérico
descrito no capítulo 2. Para isso foram criadas algumas funções como
EliminaMortosEInalcancaveis, SinalizaEstadosAlcancaveis, SinalizaEstadosVivos,
67
SinalizaEstadosMortos, CriaClassesEquivalencia. A tabela de transição e o diagrama de
transição equivalente assim como nas outras conversões são apresentados em uma nova janela do
editor.
Também é apresentado o código fonte das funções AFDparaAFDM e Minimiza no Apêndice
deste trabalho.
3.2.1 Ambiente
O software construído foi denominado pelo autor de MAFI (Máquina de Autômatos Finitos).
Como mencionado anteriormente, o software será capaz de construir, reconhecer e converter
Autômatos Finitos, assim como validar ou não uma sentença que faça parte da linguagem
reconhecida pelo autômato.
Para o usuário construir um Autômato Finito ele terá que abrir a janela de desenho pelo botão
“Novo” ou pelo “Menu Arquivo Novo”; assim poderá começar a desenhar o Autômato Finito
desejado através dos botões “Estado Inicial”, “Estado Intermediário” e “Transição” posicionados
na parte superior do software.
Para iniciar o desenho é obrigatório que o primeiro estado a ser inserido no editor seja o inicial.
Com isso é criado um estado com rótulo ‘q0’ (ou ‘qf0’ se este também for final) e preenchido com
a cor branca para diferenciar dos estados intermediários e finais que são preenchidos com a cor
amarela e com rótulos ‘q1’... ’ ‘q...’ para os estados intermediários e ‘qf1’... ‘qf...’ para os finais.
Todos os estados, inicial ou intermediários, podem se tornar finais, bastando clicar duas vezes no
botão esquerdo do mouse (o inverso também é admitido).
As transições são efetuadas de duas maneiras:
Selecionando dois estados, onde o primeiro a ser selecionado é o estado origem e o
segundo o estado destino, ou seja, a seta vai da origem para o destino com o símbolo a ser
reconhecido.
Selecionando apenas um estado, onde a transição criada é para ele mesmo, ou seja, a seta
vai para o próprio estado com o símbolo a ser reconhecido.
O símbolo é inserido de forma única, ou seja, se for necessário mostrar que, para um estado
origem exista uma transição com outro símbolo para o mesmo estado destino com o qual o estado
68
origem já possui uma transição, é preciso separar as sentenças por uma vírgula. Para
representação da sentença vazia foi admitido o caractere ‘$’.
O reconhecimento do tipo do autômato acontece quando o usuário pressiona o botão “Tipo
Autômato” ou seleciona a opção no software “Menu Reconhecer Tipo Autômato”. Realizada a
chamada, serão verificadas as propriedades contidas na tabela de transição do autômato
desenhado classificando o mesmo como um Autômato Finito Não Determinístico com
Movimento Vazio, Autômato Finito Não Determinístico ou Autômato Finito Determinístico,
conforme suas definições descritas anteriormente. O resultado será impresso na área inferior do
ambiente e será composta pelo tipo do autômato e sua respectiva tabela de transição. O
reconhecimento de cada tipo de autômato está exemplificado nas Figuras 49 a 51.
Figura 49: Reconhecimento de um Autômato Finito Não Determinístico com Movimento Vazio
O Autômato Finito Não Determinístico com Movimento Vazio representado na Figura 49,
representa a Linguagem denotada por L = {w| qualquer número de símbolos a, seguido de
qualquer número de símbolos b ou a}.
69
Figura 50: Reconhecimento de um Autômato Finito Não Determinístico
O Autômato Finito Não Determinístico representado pela Figura 50 é representado pela sentença
formada pelo símbolo {a} e que termina com a seqüência abb. O não-determinismo é
reconhecido no estado q0 com o símbolo a.
Figura 51: Reconhecimento de um Autômato Finito Determinístico
A Figura 51 representa um Autômato Finito Determinístico e sua Linguagem denotada é dada por
L = {w| |w| >= 2 e w possui aa ou bb como subsentença}.
70
Para o usuário reconhecer uma sentença é necessário que um autômato esteja desenhado e a
sentença para reconhecimento esteja inserida no campo “Digite a Sentenca”. Depois de realizados
estes passos, o usuário poderá verificar a sentença de forma direta ou passo a passo. Para realizar
de forma direta o usuário deverá clicar sobre o botão “Direto” ou selecionar no software a opção
“Menu Reconhecer Direto”. Para realizar esta verificação o software compara a sentença digitada
com as transições da tabela de transição do Autômato Finito que de forma direta (sem mostrar o
caminho percorrido), retorna se a sentença é válida ou não como ilustrado nas Figuras 52 e 53,
respectivamente.
Figura 52: Reconhecimento de uma sentença aceita de forma direta
71
Figura 53: Reconhecimento de uma sentença não aceita de forma direta
Caso a opção desejada seja passo a passo o usuário deverá clicar sobre o botão “Passo a Passo”
ou selecionar no software a opção “Menu Reconhecer Passo a Passo”. Esta opção retorna se a
sentença é válida ou não, percorrendo seu caminho como se observa nas Figuras 54 e 55
respectivamente. Este caminho é percorrido de forma análoga a direta, diferenciando-se apenas
no retorno que como foi falado mostra o caminho percorrido pela (s) sentença (s) até sua
aceitação ou não.
O estado alcançado é identificado pela cor azul.
72
Figura 54: Reconhecimento de uma sentença aceita passo a passo
73
Figura 55: Reconhecimento de uma sentença não aceita passo a passo
74
Para que o usuário realize as conversões previstas pelos Autômatos Finitos descritas
anteriormente, é preciso observar algumas pré-condições.
Para converter um Autômato Finito Não Determinístico com Movimento Vazio em um Autômato
Finito Não Determinístico o usuário obrigatoriamente deverá ter desenhado na tela do editor um
AFN-ε e selecionar a opção do software “Menu Converter AFNE - AFN” que, após executada,
retornará a tabela de transição e seu diagrama de transição equivalente em uma outra janela do
editor (Figura 56). No diagrama de transição o estado inicial estará pintado de branco; já na
tabela de transição será representado pelo caractere “>”, enquanto que o estado final será
representado por um círculo duplo no diagrama e pelo caractere “*” na tabela. Caso o autômato
não seja um AFN-ε ou o usuário escolher outro tipo de conversão, o sistema retornará uma
mensagem dizendo que não é possível realizar a conversão, como ilustra a Figuras 57.
Figura 56: Conversão de um AFN-ε em um AFN
A conversão de um Autômato Finito Não Determinístico com Movimento Vazio para um
Autômato Finito Não Determinístico como descrito anteriormente, esta representado na Figura 56
e a Linguagem denotada é dada por L = {w| qualquer número de símbolos a, seguido de qualquer
número de símbolos b ou a}. A conversão objetiva eliminar todos as transições vazias, que no
software se encontra por $.
75
Figura 57: Conversão de um AFN-ε em um AFN com Autômato de entrada errado
A conversão de um Autômato Finito Não Determinístico em um Autômato Finito Determinístico
se realiza de forma análoga a conversão anterior, sendo que a única diferença é que o Autômato
de entrada obrigatoriamente deverá ser um AFN e a opção selecionada no software deverá ser
“Menu Converter AFN - AFD” que, após executada, retornará a tabela de transição e o diagrama
de transição do AFD correspondente (Figura 58). Caso o autômato não seja um AFN ou o usuário
escolher outro tipo de conversão o sistema retornará uma mensagem dizendo que não é possível
realizar a conversão, como ilustra a Figura 59.
76
Figura 58: Conversão de um AFN em um AFD
A Linguagem denotada pelo exemplo da Figura acima é dada por L = {w| qualquer número de
símbolos a, seguidos de um símbolo b ou qualquer numero de símbolos c}.
Esta conversão é conhecida como “construção de conjuntos”, pois tem como objetivo criar todos
os subconjuntos do conjunto de estados do AFN.
Figura 59: Conversão de um AFN em um AFD com Autômato de entrada errado
77
Similar as conversões anteriores, a minimização de um Autômato Finito Determinístico difere
das outras por seu autômato de entrada ser um AFD e sua opção de conversão no software ser
“Menu Converter AFD - AFDm” que, após executada, retornará a tabela de transição do AFD
Mínimo e seu diagrama de seqüência correspondente em uma nova janela do software (Figura
60). Caso o autômato não seja determinístico, o sistema retorna uma mensagem informando que
não é possível realizar a conversão, conforme apresentado na Figura 61.
Figura 60: Conversão de um AFD em um AFDm
Para realizar a minimização é preciso seguir os passos do algoritmo genérico descrito no capítulo
2 deste trabalho, que segundo Aho; Sethi; Ullman (1995) tem como objetivo a exclusão dos
estados inacessíveis, das transições indefinidas e dos estados mortos.
78
Figura 61: Conversão de um AFD em um AFDm com Autômato de entrada errado
O software permite a minimização de qualquer Autômato Finito, desde que a seqüência correta
de transformações seja observada (AFN-ε para AFN; AFN para AFD; AFD para AFDm).
79
4 CONSIDERAÇÕES FINAIS
A Teoria de Linguagens Formais disponibiliza um conjunto de formalismos que podem ser
empregados na especificação e reconhecimento de sentenças de uma linguagem. Um
reconhecedor é um sistema que, a partir de um conjunto de símbolos que compõe a sentença,
aceita ou rejeita esta sentença, como sendo ou não uma sentença válida para uma determinada
linguagem. Os Autômatos Finitos, que são dispositivos formais utilizados no reconhecimento de
sentenças de uma Linguagem Regular, podem ser classificados em Autômatos Finitos
Determinísticos, Autômatos Finitos Não Determinísticos e Autômatos Finitos Não
Determinísticos com Movimento Vazio.
O presente trabalho desenvolveu um software educacional para construção e validação de
formalismos utilizados na geração e reconhecimentos de sentenças de uma Linguagem Regular,
de forma a assistir aos alunos e servir de apoio nas disciplinas de Linguagens Formais e
Compiladores dos cursos de Ciência da Computação e Engenharia de Computação da
Universidade do Vale do Itajaí – UNIVALI, campus São José.
Inicialmente foram estudados conceitos e teorias referentes aos Autômatos Finitos e Expressões
Regulares, assim como suas equivalências, conversões e seus respectivos algoritmos. Após o
embasamento teórico foi iniciado a modelagem do software, na qual foram construídos os
diagramas de caso de uso, diagramas de seqüência e o diagrama de aplicação usando para isso a
UML com o Enterprise Architect.
Posteriormente a modelagem deu-se início a implementação do software, cujo primeiro passo foi
o desenvolvimento da interface gráfica. Esta permite que o Autômato Finito seja inserido
graficamente na forma de seu diagrama de transição, sendo possível identificar a qual classe o
Autômato Finito desenhado pertence, assim como reconhecer uma ou mais sentenças da
linguagem representada pelo autômato. Além disto, possibilita a conversão de um Autômato
Finito Não Determinístico com Movimento Vazio em um Autômato Finito Não Determinístico,
de um Autômato Finito Não Determinístico em Autômato Finito Determinístico e também de
Autômato Finito Determinístico para Autômato Finito Determinístico Mínimo. Essas conversões
possibilitam a auto aprendizagem do aluno e facilitam a correção dos exercícios propostos pelo
professor da disciplina Linguagens Formais e Compiladores.
80
Inicialmente a linguagem Java havia sido escolhida como linguagem de implementação do
software. No entanto, o domínio restrito do autor com os recursos gráficos de Java, gerou
dificuldades para desenvolver a interface do ambiente de edição de Autômatos Finitos. Isso
ocasionou a troca da linguagem para Object Pascal no ambiente de programação do Borland
Delphi 7. Devido a esta troca, o tempo para o desenvolvimento deste trabalho ficou reduzido.
Por conseqüência, a implementação da funcionalidade de encontrar o Autômato Finito
equivalente a uma Expressão Regular não foi realizada.
A experiência de desenvolver este software educacional foi muito positiva, pois oportunizou
vivenciar situações práticas semelhantes à realidade de um futuro profissional da área de Ciência
da Computação, tais como modelar, desenvolver e testar um software, assim como analisar e
tratar possíveis erros que o usuário possa cometer ou detectar.
Como possíveis trabalhos futuros, pode-se citar:
Implementação da funcionalidade de encontrar o Autômato Finito equivalente a uma
Expressão Regular qualquer;
Implementação da funcionalidade de encontrar a Expressão Regular equivalente a um
Autômato Finito qualquer;
Implementação do software na versão on-line;
Implantar o software junto aos alunos da disciplina e verificar os resultados para
melhorias do mesmo.
81
5 REFERÊNCIAS BIBLIOGRAFICAS
AHO, Alfred V; SETHI, Ravi; ULLMAN, Jeffrey D. Compiladores, princípios, técnicas e ferramentas. Rio de Janeiro: Guanabara Koogan, 1995. 344p ISBN 8527703122. CANTÚ, Marco. Dominando o Dephi 5 – A Bíblia. 1.ed. São Paulo: Makron Books, 2000. 860p ISBN 853461184x. CERVO, Amado Luiz; BERVIAN, Pedro Alcino. Metodologia Científica. 4.ed. Sao Paulo: Makron Books, 1996. 209p. ISBN 8534605211. FOWLER, Martin. UML Essencial: Um breve guia para a linguagem-padrão de modelagem de objetos. 2.ed. Porto Alegre: Bookman, 2000. 169p. ISBN 8573077298. FURTADO, Olinto José Varela. Apostila de Linguagens Formais e Compiladores. Florianópolis. Disponível em http://www.inf.ufsc.br/~olinto/apostila-lfc.doc. Acesso em: 25 agosto 2005. HOPCROFT, John E; MOTWANI, Rajeev; ULLMAN, Jeffrey D. Introdução à teoria de Autômatos, Linguagens e Computação. Rio de Janeiro: Campus, 2002. 560p ISBN 8535210725. JOSE NETO, João. Introdução à compilação. Rio de Janeiro: Livros Tecnicos e Cientificos, 1987. 222p ISBN 85-216-0483-1. JUNG, Carlos Fernando. Metodologia Científica: ênfase em pesquisa tecnológica. 4. ed. Disponível em: http://www.jung.pro.br/. Acesso em: 01 setembro 2005. MENEZES, Paulo Fernando Blauth. Linguagens Formais e Autômatos. 3. ed. Porto Alegre: Sagra Luzzatto, 2002. 165p ISBN 8524105542. LOUDEN, Kenneth C. Compiladores: princípios e práticas. 1.ed. São Paulo: Pioneira Thomson Learning, 2004. 569p ISBN 8522104220. MARTINS, Joyce. Linguagens Formais e Compiladores. São José, 2003. Disponível em: http://ssooweb01.univali.br/prof/ALESSANDRO%20MUELLER/linguagens%20formais%20e%20compiladores/engenharia%20de%20computacao/ Acesso em: 25 agosto 2005. MORASTONI, J.P. Editor de Autômatos Finitos. FURB, 2002. (Trabalho de Conclusão de Curso), Graduação em Ciência da Computação da Universidade Regional de Blumenau, Blumenau. PRICE, Ana Maria de Alencar; TOSCANI, Simao Sirineo. Implementação de Linguagens de Programacao: Compiladores. 2. ed. Porto Alegre: Sagra Luzzatto, 2001. 195p ISBN 8524106395.
82
SILVA, Edna Lúcia; MENEZES, Estera Muszkat. Metodologia da pesquisa e elaboração de dissertação. 3. ed. Florianópolis: Laboratório de Ensino à Distância da UFSC, 2001. ZILLER, R.M. Aplicação de autômatos finitos. In: SEMANA TECNOLÓGICA, 1. Florianópolis, 1997. Anais. Biguaçu, UNIVALI, 1997. p.51-71. WIKIPEDIA. Disponível em: http://pt.wikipedia.org/wiki/Linguagem_Formal. Acesso em: 05 outubro 2005.
83
APÊNDICE
84
APÊNDICE I: Código Fonte das conversões dos Autômatos Finitos
//converte um afne em afn procedure TForm2.AFNEparaAFN; var nDet: TAutomato; i, indice, colunaMoVazio, colunaNDet : integer; transi, transiVazio, proxtransiVazio : string; begin if Af.TpAutomatoAFNDe then begin Af.GeraAutomato; //copia o alfabeto menos a sentenca '$' colunaNDet := 2; for i := 3 to Af.Automato.coluna do begin if Af.Automato.matriz[0,i] <> '$' then begin inc(colunaNDet); nDet.matriz[0,colunaNDet] := Af.Automato.matriz[0,i]; end; end; nDet.coluna := colunaNDet; //copia os estados for i := 1 to Af.Automato.linha do begin nDet.matriz[i,0] := Af.Automato.matriz[i,0]; nDet.matriz[i,1] := Af.Automato.matriz[i,1]; nDet.matriz[i,2] := Af.Automato.matriz[i,2]; end; nDet.linha := Af.Automato.linha; //percorrer matriz para gerar o automato convertido... colunaMoVazio := Af.ColunaAlfab('$',Af.Automato); if colunaMoVazio <> -1 then begin for i := 1 to Af.Automato.linha do begin transi := Af.Automato.matriz[i,colunaMoVazio]; for indice := 3 to nDet.coluna do begin nDet.matriz[i,indice] := Af.GeraTransVazio(transi, i, nDet.matriz[0,indice]); end; transivazio := transi; proxtransiVazio := Af.PossuiTransVazio(transivazio); while (proxtransiVazio <> '') and (proxtransiVazio <> transiVazio) do
85
begin for indice := 3 to nDet.coluna do begin nDet.matriz[i,indice] := Af.concatenaEstados(nDet.matriz[i,indice], proxtransiVazio); end; transiVazio := proxtransiVazio; proxtransiVazio := Af.PossuiTransVazio(transiVazio); end; //atribui estado final aos estados com transicoes para '$' if transi <> '' then begin nDet.matriz[i,1] := '*'; end; end; end; Af.GeraLista(nDet); self.MostraAutomatoConvertido; end else self.Mensagem.Lines.Add('NAO E UM AUTOMATO FINITO NAO DETERMINISTICO COM MOVIMENTO VAZIO'); end;
Quadro 1: Código Fonte Converter um AFN-ε em um AFN
//converte um afn em afd (determiniza um automato nao deterministico)
procedure TForm2.AFNparaAFD;
var
det: TAutomato;
i, linhaAtual : integer;
transi : string;
begin
if not (Af.TpAutomatoAFNDe) and not (Af.TpAutomatoDet) then
begin
Af.GeraAutomato;
//copia o alfabeto
for i:=3 to Af.Automato.coluna do
begin
det.matriz[0,i] := Af.Automato.matriz[0,i];
86
end;
det.coluna := Af.Automato.coluna;
//copia o estado inicial
for i:=1 to Af.Automato.linha do
begin
if(Af.Automato.matriz[i,0] = '>') then
begin
det.matriz[1,0] := '>';
det.matriz[1,2] := Af.Automato.matriz[i,2];
if(Af.Automato.matriz[i,1] = '*') then
det.matriz[1,1] := '*';
break;
end;
end;
det.linha := 0;
linhaAtual := 1;
//gera transicoes
while det.linha < linhaAtual do
begin
Inc(det.linha);
for i := 3 to det.coluna do
begin
transi := Af.TransicaoAut(det.matriz[det.linha,2],det.matriz[0,i],Af.Automato); //retorna
estado concatenado
if transi <> '' then //compara para ver se a transicao e vazia
begin
det.matriz[det.linha,i] := transi;
if Af.LinhaEstado(transi,det) = -1 then
begin
Inc(LinhaAtual);
det.matriz[linhaAtual,2] := transi;
87
if Af.EhEstadoFinal(Af.Automato,transi) then
begin
det.matriz[linhaAtual,1] := '*';
end;
end;
end;
end;
end;
Af.GeraLista(det);
self.MostraAutomatoConvertido;
end else
self.Mensagem.Lines.Add('NAO E UM AUTOMATO FINITO NAO DETERMINISTICO');
end;
Quadro 2: Código Fonte Converter um AFN em um AFD
/converte um afd em afdm procedure TForm2.AFDtoAFDM; var i,j : integer; teste: string; min: TAutomato; begin min := Af.Minimiza(); Af.GeraLista(min); self.MostraAutomatoConvertido; end; //funcao para minimizar o automato deterministico function TAf.Minimiza() : TAutomato; var det, min: TAutomato; equiLinha, auxLinha: integer; equi, aux: TStringList; indice: Integer; begin equi := TStringList.Create; aux := TStringList.Create;
88
for indice := 0 to 400 do begin equi.Add(''); aux.Add(''); end; self.GeraAutomato; det := self.Automato; PreencheIndefinicoes(det); // Cria estado '-', caso o autômato possua indefinicões(transicoes vazias) CriaEstadoIndefinicao(det); //Acha estados alcancaveis SinalizaEstadosAlcancaveis(det); //acha estados vivos SinalizaEstadosVivos(det); //verifica se tem algum estado morto SinalizaEstadosMortos(det); //elimina estados mortos e inalcancaveis min := EliminaMortosEInalcancaveis(det); //cria classes de equivalencia CriaClassesEquivalencia(min, equi, equiLinha); //Cria novas geracoes de classes CriaNovasClasses(equi, equiLinha, min, aux, auxLinha); result := GeraAutomatoMinimo(min, aux, auxlinha); equi.Free; aux.Free; end;
Quadro 3: Código Fonte Converter um AFD em um AFDM
89
APÊNDICE II: Manual do Usuário
MAFI - MANUAL DO USUÁRIO
90
ÍNDICE
1 – INSTALAÇÃO----------------------------------------------------------------------------------------------------------------04
2 – FUNCIONAMENTO --------------------------------------------------------------------------------------------------------04
91
ÍNDICE DE FIGURAS
Figura1: Abrir um novo arquivo para edição através do botão ---------------------------------------------------------05 Figura2: Abrir um novo arquivo para edição através do menu arquivo-----------------------------------------------05 Figura3: Salvar um documento através do botão---------------------------------------------------------------------------05 Figura4: Salvar um documento através do menu arquivo ----------------------------------------------------------------06 Figura5: Abrir um documento do arquivo através do botão -------------------------------------------------------------06 Figura6: Abrir um documento do arquivo pelo menu arquivo ----------------------------------------------------------06 Figura7: Editor pronto para ser usado ---------------------------------------------------------------------------------------07 Figura8: Editor com um autômato desenhado ------------------------------------------------------------------------------07 Figura9: Verificar tipo de autômato pelo botão-----------------------------------------------------------------------------08 Figura10: Verificar tipo de autômato pelo menu ---------------------------------------------------------------------------08 Figura11: Verificar sentença passo a passo ----------------------------------------------------------------------------------09 Figura12: Verificar sentençadireto --------------------------------------------------------------------------------------------09 Figura13: Converter de AFNDe para AFND --------------------------------------------------------------------------------09 Figura14: Converter de AFND para AFD------------------------------------------------------------------------------------10 Figura15: Converter de AFD para AFDm -----------------------------------------------------------------------------------10 Figura16: Imprimir um autômato ---------------------------------------------------------------------------------------------10 Figura17: Sair do editor de autômatos----------------------------------------------------------------------------------------11
92
MANUAL DO USUÁRIO
1 – INSTALAÇÃO
A instalação da Máquina de Autômatos Finitos (MAFI) é simples de ser realizada, basta seguir os
seguintes passos descritos a seguir:
1° Passo: descompactar o arquivo “MAFI.rar” em qualquer diretório da máquina desejada.
Após o término do processo de descompactação, a pasta com a biblioteca necessária e o arquivo
executável estará criada no diretório escolhido.
2° Passo: com o botão direito do mouse, clicar em cima do arquivo executável “MAFI.exe” e
escolher a opção “enviar para área de trabalho (criar atalho)”, depois de realizado esse passo,
um ícone do executável do programa será criado no desktop do micro.
Concluído estes passos, seu programa está instalado e pronto para ser usado.
2 – FUNCIONAMENTO
Para iniciar o programa, basta clicar duas vezes com o botão esquerdo do mouse no atalho criado
no desktop. Na seqüência, aparecerá uma janela de inicialização que contém a logotipo da
UNIVALI. Esta janela ficara na tela durante aproximadamente 5 segundos, quando uma outra
janela se abrirá. Esta é a janela principal do programa.
Nesta janela estarão as funções necessárias para criar, abrir, salvar, converter, reconhecer e
imprimir os autômatos desejados.
Para abrir um novo arquivo para edição de um autômato basta clicar no “botão” ou no “menu
Arquivo Novo”, como mostram as Figuras 1 e 2 respectivamente.
93
Figura1: Abrir um novo arquivo para edição através do botão
Figura2: Abrir um novo arquivo para edição através do menu arquivo
Um autômato construído ou que esteja em construção pode ser salvo pressionando o “botão” ou pelo “menu Arquivo Salvar”, como pode-se observar nas Figuras 3 e 4 respectivamente.
Figura3: Salvar um documento através do botão
94
Figura4: Salvar um documento através do menu arquivo
Depois de salvo em um arquivo, basta abri-lo para utilizá-lo. Para fazer isso, é só utilizar o “botão” na tela principal ou o “menu Arquivo Abrir”, como demonstrado nas Figuras 5 e 6 a seguir.
Figura5: Abrir um documento do arquivo através do botão
Figura6: Abrir um documento do arquivo pelo menu arquivo
95
Para começar a desenvolver o desenho de um autômato, depois de ter aberto o editor para um
novo documento ou abrir um já existente, basta clicar sobre os botões (estado inicial, transição e
estados) que se encontram no menu superior como se observa na Figura 7 a seguir. A Figura 8
ilustra um autômato construído.
Figura7: Editor pronto para ser usado
Figura8: Editor com um autômato desenhado
Com o autômato desenhado, pode-se executar algumas funcionalidades, como:
Identificar o tipo do autômato criado (se ele é um AFN-ε, AFN ou AFD) através do
“botão” como mostra a Figura 9, e pelo “menu Reconhecer Tipo de Autômato”,
conforme a Figura 10.
Verificar uma sentença passo a passo ou diretamente Figuras 11, 12.
96
Converter um autômato de AFN-ε para AFN.(Figura 13).
Converter um autômato de AFN para AFD.(Figura 14).
Converter um autômato de AFD para AFDm.(Figura 15).
Imprimir este autômato através do botão, conforme Figura 16.
Sair da ferramenta através do botão ou da opção do menu, Figura 17.
Figura9: Verificar tipo de autômato pelo botão
Figura10: Verificar tipo de autômato pelo menu
97
Figura11: Verificar sentença passo a passo
Figura12: Verificar sentence direto
Figura13: Converter de AFN-ε para AFND
98
Figura14: Converter de AFN para AFD
Figura15: Converter de AFD para AFDm
Figura16: Imprimir um autômato
99
Figura17: Sair do editor de autômatos