99
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

UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

Embed Size (px)

Citation preview

Page 1: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 2: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 3: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 4: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 5: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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)

Page 6: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 7: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 8: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 9: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 10: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 11: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 12: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 13: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 14: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 15: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 16: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 17: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 18: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 19: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 20: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 21: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 22: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 23: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 24: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 25: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 26: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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)

Page 27: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 28: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 29: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 30: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 31: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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;

Page 32: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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}

Page 33: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 34: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 35: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 36: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 37: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 38: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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)

Page 39: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 40: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 41: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 42: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 43: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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 | _)*

Page 44: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 45: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 46: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 47: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 48: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 49: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 50: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 51: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 52: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 53: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 54: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 55: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 56: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 57: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 58: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 59: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 60: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 61: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 62: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 63: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 64: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 65: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 66: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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,

Page 67: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 68: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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}.

Page 69: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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}.

Page 70: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 71: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 72: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

72

Figura 54: Reconhecimento de uma sentença aceita passo a passo

Page 73: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

73

Figura 55: Reconhecimento de uma sentença não aceita passo a passo

Page 74: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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 $.

Page 75: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 76: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 77: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 78: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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).

Page 79: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 80: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 81: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 82: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 83: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

83

APÊNDICE

Page 84: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 85: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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];

Page 86: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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;

Page 87: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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;

Page 88: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 89: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

89

APÊNDICE II: Manual do Usuário

MAFI - MANUAL DO USUÁRIO

Page 90: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

90

ÍNDICE

1 – INSTALAÇÃO----------------------------------------------------------------------------------------------------------------04

2 – FUNCIONAMENTO --------------------------------------------------------------------------------------------------------04

Page 91: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 92: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 93: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 94: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 95: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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.

Page 96: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

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

Page 97: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

97

Figura11: Verificar sentença passo a passo

Figura12: Verificar sentence direto

Figura13: Converter de AFN-ε para AFND

Page 98: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

98

Figura14: Converter de AFN para AFD

Figura15: Converter de AFD para AFDm

Figura16: Imprimir um autômato

Page 99: UNIVERSIDADE DO VALE DO ITAJAÍ - UNIVALIsiaibib01.univali.br/pdf/Paulo Roberto Lima.pdf ·  · 2007-07-24for specification and recognition of sentences of a programming language

99

Figura17: Sair do editor de autômatos