Ferramenta para auxílio na aprendizagem de linguagens formais e autômatos

UNIVERSIDADE COMUNITÁRIA DA REGIÃO DE CHAPECÓ
ÁREA DE CIÊNCIAS EXATAS E AMBIENTAIS
CURSO DE CIÊNCIA DA COMPUTAÇÃO
(BACHARELADO)
FERRAMENTA PARA AUXÍLIO NA APRENDIZAGEM DE LINGUAGENS
FORMAIS E AUTÔMATOS
LUAN FELIPE DA SILVA KNEBEL
CHAPECÓ, JUNHO DE 2017

UNIVERSIDADE COMUNITÁRIA DA REGIÃO DE CHAPECÓ
ÁREA DE CIÊNCIAS EXATAS E AMBIENTAIS
CURSO DE CIÊNCIA DA COMPUTAÇÃO
(BACHARELADO)
Relatório do Trabalho de Conclusão de Curso
submetido à Universidade Comunitária da
Região de Chapecó para obtenção do título de
Bacharelado no curso de Ciência da
Computação.
Orientador(a): Prof(ª). Viviane Duarte
Bonfim, MSc.

iii
ESTE RELATÓRIO, DO TRABALHO DE CONCLUSÃO DE CURSO, FOI
JULGADO ADEQUADO PARA OBTENÇÃO DO TÍTULO DE:
BACHAREL EM CIÊNCIA DA COMPUTAÇÃO
Prof (a). Viviane Duarte Bonfim, M.Sc.
Orientador
BANCA EXAMINADORA:
Prof. José Carlos Toniazzo, Esp.
Unochapecó
Prof. Sandro Silva de Oliveira, MSc.
Unochapecó
Prof. Sandro Silva de Oliveira, MSc.
Supervisor de TCC
Prof. Jorge Antonio Di Domenico, MSc.
Coordenador de Curso

iv
Dedico este trabalho à minha família, em
especial a minha esposa Juliane Sbeghen.

v
Agradeço a Professora Viviane Duarte Bonfim
pelo auxílio prestado para a conclusão deste
trabalho.

vi
“A única maneira de fazer um excelente
trabalho é amar o que você faz. “
Steve Jobs.

vii
LISTA DE ILUSTRAÇÕES
FIGURA 1 : Símbolo, Alfabeto, Cadeia Da Linguagem ........................................................................................ 9
FIGURA 2 : Relação Hierárquica Entre as Classes De Linguagens da Hierarquia De Chomsky........................ 12
FIGURA 3 : Máquina de Turing Com Fita Ilimitada........................................................................................... 14
FIGURA 4 : Árvore de Derivação........................................................................................................................ 16
FIGURA 5 : Máquina de Turing Com Fita Limitada........................................................................................... 18
FIGURA 6 : Um Autômato de Pilha é Essencialmente um Autômato Finito com uma Estrutura De Pilha.. ...... 21
FIGURA 7 : Lexemas de uma Expressão............................................................................................................. 27
FIGURA 8 : Autômato Finito Construído a Partir de uma Gramática Regular.................................................... 32
FIGURA 9 : Um Autômato Finito que Modela um Interruptor Liga/Desliga...................................................... 34
FIGURA 10 : Autômato Gerado pela Tabela 3 Da Gramática G¹........................................................................ 36
FIGURA 11 : Um Autômato Finito que Modela o Reconhecimento De Then..................................................... 36
FIGURA 12 : Diagrama do Autômato AFD. ....................................................................................................... 37
FIGURA 13 : Diagrama do Autômato AFND...................................................................................................... 38
FIGURA 14 : Diagrama do Autômato AFND para Transformação..................................................................... 41
FIGURA 15 : Autômato Finito Determinístico AFD........................................................................................... 43
FIGURA 16 : Ferramenta VAS............................................................................................................................ 44
FIGURA 17 : Ferramenta GAM........................................................................................................................... 45
FIGURA 18 : Ferramenta JFLAP......................................................................................................................... 46
FIGURA 19 : Ferramenta Language Emulator. ................................................................................................... 48
FIGURA 20 : Ferramenta SCTMF....................................................................................................................... 49
FIGURA 21 : Demonstração dos Passos da Ferramenta VRL (Virtual Regular Language). ............................... 56
FIGURA 22 : Campos da Gramática Regular...................................................................................................... 57
FIGURA 23 : Demonstração da Tabela Da Ferramenta....................................................................................... 58
FIGURA 24 : Modelo de Um Autômato.............................................................................................................. 59
FIGURA 25 : Transformação AFND Para AFD ................................................................................................. 60
FIGURA 26 : Validação da Sentença da Ferramenta........................................................................................... 61
FIGURA 27 : Modelagem de Classes Uml da Ferramenta VRL ......................................................................... 62
FIGURA 28 : Arquitetura de Classes da Ferramenta VRL (Virtual Regular Language)..................................... 67
FIGURA 29 : Estrutura de Classe para Representação do Autômato. ................................................................. 72
FIGURA 30 : Quatro Etapas da Ferramenta VRL................................................................................................ 80
FIGURA 31 : Etapa de Validação da Gramática Regular. ................................................................................... 81
FIGURA 32 : Etapa da Tabela de Transição e Autômato AFND ........................................................................ 81
FIGURA 33 : Etapa da Transformação de AFND Para AFD............................................................................... 82
FIGURA 34 : Etapa de Validação de Sentença.................................................................................................... 83
FIGURA 35 : Etapa de Validação de Sentença com uma Sentença Inválida....................................................... 84

viii
LISTA DE QUADROS
QUADRO 1: Cadeias de Símbolos. ....................................................................................................... 7
QUADRO 2: Conjunto de Cadeias ........................................................................................................ 7
QUADRO 3: Potenciação de Cadeias.................................................................................................... 7
QUADRO 4: Gramática Irrestrita. ....................................................................................................... 13
QUADRO 5: Produção de uma Gramática Irrestrita............................................................................ 13
QUADRO 6: Gramática de uma Linguagem Sensível Ao Contexto. .................................................. 16
QUADRO 7: Gramática Sensível ao Contexto com Produções........................................................... 17
QUADRO 8: Derivação de Uma Gramática Sensível ao Contexto. .................................................... 17
QUADRO 9: Notação Backus Naur Form........................................................................................... 19
QUADRO 10: Gramática de uma Linguagem Livre de Contexto. ...................................................... 20
QUADRO 11: Derivação de Uma Gramática Livre de Contexto. ....................................................... 20
QUADRO 12: Gramática Regular. ...................................................................................................... 26
QUADRO 13: Regras de Uma Gramática Regular.............................................................................. 27
QUADRO 14: Regras de Expressões Regulares.................................................................................. 28
QUADRO 15: Conjunto de Cadeias de Uma Expressão Regular........................................................ 28
QUADRO 16: Exemplo de Expressão Regular.................................................................................... 29
QUADRO 17: Estrutura da Gramática Regular................................................................................... 31
QUADRO 18: Derivação da Gramática Regular. ................................................................................ 31
QUADRO 19: Exemplo de Gramática Regular para uma Tabela de Transição. ................................. 35
QUADRO 20: Código Fonte para Validações da Gramática Regular. ................................................ 70
QUADRO 21: Código Fonte para Validações das Produções da Gramática Regular. ....................... 71
QUADRO 22: Código Fonte do Mapeamento das Transições dos Estados......................................... 73
QUADRO 23: Código Fonte para Identificar o Tipo da Gramática..................................................... 75
QUADRO 24: Código Fonte para Identificação de Novos Estados para Transições não
Determinísticas.............................................................................................................................. 76
QUADRO 25: Código Fonte da Simplificação do Nome de Estados. ................................................. 77
QUADRO 26: Código Fonte para Validação de Sentença................................................................... 79

ix
LISTA DE TABELAS
TABELA 1: Lista de Meta-Caracteres de Expressões Regulares. ....................................................... 29
TABELA 2: Transições Construídas a Partir das Produções. .............................................................. 32
TABELA 3: Tabela de Transições da Gramática G¹............................................................................ 35
TABELA 4: Tabela da Autômato Finito Determinístico ..................................................................... 37
TABELA 5: Tabela da Autômato Finito Não Determinístico.............................................................. 38
TABELA 6: Tabela AFND .................................................................................................................. 40
TABELA 7: Tabela de Transformação de AFND para AFD............................................................... 42
TABELA 8: Tabela de Transformação AFD. ...................................................................................... 42
TABELA 9: Comparação das Funcionalidades Implementadas em cada Ferramenta......................... 51
TABELA 10: Comparação do Tipo de Demonstração das Ferramentas.............................................. 52

x
LISTA DE SIGLAS
AFD - Autômato Finito Deterministico
AFND - Autômato Finito Não Determinístico
BNF - Backus-Naur Form
ER - Expressão Regular
GAM - Ginux Abstract Machine
GR - Gramática Regular
IDE - Integrated Development Environment
IP - Internet Protocol
JFLAP - Java Formal Languages and Automata Theory
LFA - Linguagens Formais e Autômatos
LIFO - Last In, First Out
LR - Linguagem Regular
MT - Máquina de Turing
PDF - Portable Documento Format
SCTMF - Software para a Criação e Teste de Modelos Formais
UML - Unified Modeling Language
VAS - Virtual Automata Simulator
VRL - Virtual Regular Language

xi
RESUMO
As Linguagens Formais e Autômatos são uma das principais subáreas da computação.
A partir de seus formalismos, com o auxílio da matemática, uma linguagem pode ser
computada e interpretada por uma máquina de estados conhecida como computador. Este
assunto se torna complexo quando apresentado em cursos de computação por sua
complexidade matemática, dificultando no ensino-aprendizado dos estudantes. Neste
contexto, este trabalho apresenta uma ferramenta que auxilia no estudo e facilita a
compreensão dos conceitos básicos abordados em Linguagens Formais e Autômatos. Mais
especificamente o conteúdo das Linguagens Regulares da Hierarquia de Chomsky,
demonstrando de forma simples, tabelas de transições de estados, autômatos finitos
determinísticos e não determinísticos, a partir de uma gramática regular informada na
ferramenta. Desta forma os estudantes de Computação poderão compreender de forma
simples os conceitos abordados em sala de aula, a partir das informações disponibilizadas pela
ferramenta proposta neste trabalho.
Palavras-chave: linguagens, autômatos, gramáticas, linguagem regular.

xii
ABSTRACT
The Formal Languages and Automata are one of the main subareas of computing.
From their formalisms, with the aid of mathematics, a language can be computed and
interpreted by a machine of states known as a computer. This subject becomes complex when
presented in courses of computation by its mathematical complexity, hindering in the
teaching-learning of the students. In this context, this paper presents a tool that assists in the
study and facilitates the understanding of the basic concepts discussed in Formal Languages
and Automata, specifically the content of the Regular Languages of the Chomsky Hierarchy,
with a simple demonstration of tables of state transitions, finite automata Deterministic and
nondeterministic, from a regular grammar reported in the tool. In this way, students of
Computing will be able to understand in a simple way, the concepts approached in the
classroom, based on the information provided by the tool proposed in this work.
Keywords: language, automata, grammar, regular language;

xiii
SUMÁRIO
LISTA DE ILUSTRAÇÕES..................................................................................................vii
LISTA DE QUADROS..........................................................................................................viii
LISTA DE TABELAS.............................................................................................................ix
LISTA DE SIGLAS..................................................................................................................x
RESUMO..................................................................................................................................xi
ABSTRACT ............................................................................................................................xii
1 INTRODUÇÃO .....................................................................................................................1
1.1 Contextualização...............................................................................................................1
1.2 Delimitação do Problema..................................................................................................2
1.3 Objetivos...........................................................................................................................2
1.3.1 Objetivo Geral ....................................................................................................................... 2
1.3.2 Objetivos Específicos............................................................................................................. 2
1.4 Justificativa.......................................................................................................................3
1.5 Metodologia......................................................................................................................4
2 LINGUAGENS FORMAIS E AUTÔMATOS ...................................................................5
2.1 Contextualização...............................................................................................................5
2.2 Conceitos Básicos.............................................................................................................6
2.3 Linguagens........................................................................................................................8
2.4 Gramáticas ......................................................................................................................10
2.5 Tipos de Linguagens.......................................................................................................11
2.5.1 Linguagens Enumeráveis Recursivamente - Tipo 0.............................................................. 12
2.5.1.1 Máquina de Turing............................................................................................................ 14
2.5.2 Linguagens Sensíveis ao Contexto - Tipo 1........................................................................... 15
2.5.2.1 Máquina de Turing com Fita Limitada............................................................................... 17
2.5.3 Linguagens Livres de Contexto - Tipo 2................................................................................ 18
2.5.3.1 Autômato de Pilha............................................................................................................. 21
2.5.4 Linguagens Regulares - Tipo 3.............................................................................................. 22
2.5.4.1 Autômatos Finitos ............................................................................................................. 23
2.6 Considerações Finais do Capítulo...................................................................................24
3 LINGUAGENS REGULARES ..........................................................................................25
3.1 Contextualização.............................................................................................................25
3.2 Representação .................................................................................................................26

xiv
3.3 Expressões Regulares .....................................................................................................27
3.4 Gramáticas Regulares .....................................................................................................30
3.5 Autômatos Finitos...........................................................................................................32
3.5.1 Autômatos Finitos Determinísticos (AFD)............................................................................ 37
3.5.2 Autômatos Finitos Não Determinísticos (AFND).................................................................. 38
3.5.3 Transformação de Autômato Finito Não Determinístico (AFND) para Autômato Finito
Determinístico (AFD)..................................................................................................................... 39
3.6 – Ferramentas Para Linguagens Formais e Autômatos ..................................................43
3.6.1 Ferramenta VAS ................................................................................................................... 44
3.6.2 Ferramenta GAM.................................................................................................................. 45
3.6.3 Ferramenta JFLAP................................................................................................................. 46
3.6.4 Ferramenta Language Emulator........................................................................................... 47
3.6.5 Ferramenta SCTMF............................................................................................................... 48
3.6.6 Ferramenta Virtual Regular Language (VRL)........................................................................ 49
3.6.7 - Comparativo das Ferramentas........................................................................................... 50
3.7 - Considerações Finais do Capítulo ................................................................................52
4 - MODELAGEM DA FERRAMENTA.............................................................................53
4.1 - Contextualização ..........................................................................................................53
4.2 - Descrição da Ferramenta..............................................................................................53
4.3 Estrutura da Ferramenta..................................................................................................54
4.3.1 Etapa 1: Dados da gramática................................................................................................ 54
4.3.2 Etapa 2: Tabela de Transição de Estados ............................................................................. 54
4.3 3 Etapa 3: Transformação do Autômato Finito Não Determinístico (AFND) para Autômato
Finito Determinístico (AFD)........................................................................................................... 55
4.3.4 Etapa 4: Execução do Autômato Finito e Validação de Sentenças ...................................... 55
4.4 - Funcionalidades............................................................................................................56
4.4.1 - Gramática Regular.............................................................................................................. 56
4.4.2 - Tabela de Transição de Estados ......................................................................................... 58
4.4.3 - Demonstração do Autômato AFND.................................................................................... 59
4.4.4 – Transformação de Autômato Finito Não Determinístico (AFND) para Autômato Finito
Determinístico (AFD)..................................................................................................................... 60
4.4.5 - Validação de Sentenças...................................................................................................... 61
4.5 Estrutura da Ferramenta......................................................................................................... 61
4.6 - Considerações Finais do Capítulo ................................................................................64
5 IMPLEMENTAÇÃO DA FERRAMENTA VIRTUAL REGULAR LANGUAGE .....65

xv
5.1 Tecnologias Utilizadas....................................................................................................65
5.2 Requisitos Mínimos para a Utilização da Ferramenta VRL...........................................66
5.3 Implementação da Ferramenta VRL...............................................................................67
5.3.1 Desenvolvimento da Validação da Gramática Regular ........................................................ 69
5.3.2 Desenvolvimento do Autômato Gramática Regular ............................................................ 71
5.3.3 Desenvolvimento da Transformação do Autômato Finito Não Determinístico (AFND) para
Autômato Finito Determinístico (AFD).......................................................................................... 74
5.3.2 Desenvolvimento da Validação de Sentenças...................................................................... 78
5.4 Demonstração da Ferramenta VRL ................................................................................80
5.4.1 Validação da Gramática. ...................................................................................................... 80
5.4.2 Tabela de Transição.............................................................................................................. 81
5.4.3 Tabela de Transição.............................................................................................................. 82
5.4.4 Validação de Sentença ......................................................................................................... 83
5.5 Considerações Finais do Capitulo...................................................................................84
6 CONCLUSÕES....................................................................................................................86
6.1 Trabalhos Futuros. ..........................................................................................................87
REFERÊNCIAS BIBLIOGRÁFICAS .................................................................................88
APÊNDICE A – MANUAL DA FERRAMENTA VIRTUAL REGULAR LANGUAGE
..................................................................................................................................................91

1
1 INTRODUÇÃO
1.1 Contextualização
A Teoria da Computação é uma das principais áreas de estudo nos cursos de Ciência
da Computação. No entanto, existem várias subáreas de estudo, e uma delas é as Linguagens
Formais e Autômatos. Através da área de Linguagens Formais e Autômatos é possível
compreender a formalização, características das linguagens e as especificações de um modelo
formal para uma determinada linguagem, bem como uma linguagem de programação.
Toda linguagem de programação necessita de uma formalização para que um
computador possa interpretar e executar um código. Estas formalizações podem ser
especificadas a partir de gramáticas representadas por combinação de símbolos, dependendo
da linguagem formal. Essas gramáticas são definidas através de regras e padrões que a sintaxe
da linguagem deve seguir para que um programa possa ser executado com sucesso. Dessa
forma, é possível entender a importância do estudo de linguagens formais e autômatos para a
computação e esclarecer o seu uso na construção de compiladores e interpretadores.
Dependendo da linguagem formal, para que um computador possa executar uma
gramática, é necessário construir um modelo de estados a partir dela. No caso de algumas
linguagens, as gramáticas podem ser representados pelos autômatos. Os autômatos são
construídos para que uma máquina de estados (computador) possa executar as instruções
dadas pela gramática construída a partir de uma linguagem, podendo realizar as validações de
entrada de dados como uma linguagem de programação.
Sobretudo, o estudo das linguagens formais necessita de uma lógica avançada para
poder construir e compreender as suas gramáticas e formalismos, tornando a disciplina um
tanto complexa para os estudantes de ciência da computação. Para amenizar este problema, o
objetivo deste trabalho é desenvolver uma ferramenta que facilita o estudo dos conceitos
iniciais da disciplina de Linguagens Formais e Autômatos.

2
1.2 Delimitação do Problema
A disciplina de Linguagens Formais e Autômatos demonstra uma maior complexidade
na computação, pois o seu conteúdo possui características matemáticas, considerado
complexo e muitas vezes abstrato para o aluno. Isso resulta, muitas vezes, na dificuldade de
compreensão da disciplina de Linguagens Formais e Autômatos.
Desta forma, o problema deste trabalho concentra, na dificuldade de entendimento da
disciplina de Linguagens Formais e Autômatos, devido a sua complexidade, especificamente
em relação às Linguagens Regulares, primeira Linguagem da Hierarquia de Chomsky
trabalhada na disciplina.
1.3 Objetivos
1.3.1 Objetivo Geral
Desenvolver uma ferramenta para auxiliar no ensino-aprendizagem da
disciplina de Linguagens Formais e Autômatos.
1.3.2 Objetivos Específicos
A) Demonstrar a construção dos autômatos finitos graficamente.
B) Demonstrar a execução do autômato finito para a validação de uma sentença.
C) Permitir a demonstração de gramáticas regulares.

3
1.4 Justificativa
Linguagens Formais e Autômatos é uma das disciplinas essenciais da teoria da
computação nos cursos de graduação em ciência da computação. A exploração dessa área é de
grande importância para compreender o funcionamento das linguagens computacionais e
utilizar seus conceitos para o desenvolvimento de novas tecnologias.
O estudo das linguagens formais é importante para compreender o funcionamento da
construção de padrões e formalismos de uma linguagem, e por isso, o seu estudo é
considerado complexo para os estudantes de computação. Sobretudo, por conter conceitos
baseados na teoria da computação, o seu conteúdo possui características matemáticas
aplicadas em símbolos que representam de forma lógica uma regra de sintaxe de uma
linguagem.
Estas representações simbólicas são abstratas para os estudantes que ainda não tiveram
o contato com a teoria da computação, dificultando, muitas vezes, o aprendizado do seu
conteúdo (COSTA, MENESES, UBER, 2008).
Devido a essa dificuldade, alternativas vêm sendo criadas para minimizar esse
entendimento do conteúdo de Linguagens Formais e Autômatos. Uma alternativa é a própria
tecnologia como apoio ao ensino-aprendizagem da disciplina. Como exemplo, ferramentas
estão sendo desenvolvidas para facilitar o aprendizado desses conteúdo, como a ferramenta
GAM apresentada no XXV Congresso da Sociedade Brasileira da Computação em 2005 e a
ferramenta SCTMF apresentada no XXVIII Congresso do Curso de Ciência da Computação
em 2008. Essas ferramentas focam muito em exemplos e demonstrações interativas do
funcionamento das gramáticas e autômatos, demonstrando os processos realizados pelas
gramáticas para validar uma sentença ou a construção de um autômato (JUKEMURA,
NASCIMENTO, UCHÔA, 2005).
No entanto, muitas das ferramentas existentes hoje no mercado são completas e
possuem recursos avançados, dificultando, muitas vezes o seu uso em conteúdos iniciais na
disciplina de Linguagens Formais e Autômatos. Para minimizar esse problema, entende-se
que uma ferramenta com recursos mais práticos e fáceis de utilizar focado em conceitos
iniciais da disciplina, poderia ser mais efetivo no processo de ensino aprendizagem,
especialmente no conteúdo de Linguagens Regulares.

4
Através da ferramenta, o estudante poderá utilizá-la desde as primeiras aulas, devido a
sua simplicidade de compreender os primeiros conteúdos demonstrados na disciplina.
1.5 Procedimentos Metodológicos
Para a execução deste trabalho, inicialmente foi realizado um estudo sobre Linguagens
Formais e Autômatos, demonstrando a sua importância e aplicabilidade na teoria da
computação.
Após o estudo das linguagens formais, é apresentado os tipos de linguagens
representadas pela hierarquia de Chomsky, demonstrando os conceitos de cada uma. Será
dado ênfase às linguagens regulares, pois esta será o foco deste trabalho.
Após a demonstração as linguagens regulares, foi apresentado neste trabalho os
autômatos finitos, reconhecedores de linguagens, e como eles trabalham em conjunto com as
linguagens regulares para realizar a demonstração e a execução das gramáticas regulares
representadas por símbolos.
Através dos estudos realizados citados acima, será apresentado o projeto de uma
ferramenta utilizando as tecnologias Java, Apache Maven e Eclipse IDE, com o objetivo de
auxiliar no ensino-aprendizagem da disciplina de Linguagens Formais e Autômatos. Esta
ferramenta terá o foco em linguagens regulares, com a construção de autômatos e suas
representações gráficas a partir de uma gramática informada.
Após, será demonstrado a validação de uma sentença, com o objetivo de facilitar o
funcionamento dos passos executados pelas gramáticas para validar uma sentença a partir de
uma linguagem regular.
Finalizadas essas etapas, será demonstrada a ferramenta. Após a demonstração da
ferramenta, serão apresentadas as considerações finais sobre o trabalho.

5
2 LINGUAGENS FORMAIS E AUTÔMATOS
Este capítulo apresenta os conceitos das Linguagens Formais e Autômatos (LFA), os
tipos de linguagens da Hierarquia de Chomsky com enfoque nas linguagens regulares e suas
representações gramaticais. Ainda são apresentadas demonstrações a partir de autômatos e
ferramentas existentes para estudo dos conceitos de LFA (Linguagens Formais e Autômatos).
A matemática é considerada a principal ferramenta para o desenvolvimento de teorias,
soluções e estudos da Computação. A partir de seus conceitos baseados em algoritmos, teoria
dos conjuntos, análise numérica e aritmética, matemáticos como John Von Neumann e Alan
Turing realizaram grandes contribuições para o desenvolvimento das principais teorias da
computação, as quais ainda são utilizadas em tecnologias e soluções de problemas
computacionais. Suas contribuições foram de muita importância para a teoria das Linguagens
Formais e Autômatos para que os conceitos da matemática pudessem ser aplicadas para
desenvolver padrões e regras para a definição de uma linguagem artificial
(KOWALTOWSKI, TOMASZ,1996).
O estudo das linguagens formais iniciou em 1950 a partir da necessidade de
desenvolver teorias relacionadas às linguagens naturais. Uma linguagem é formada pela
necessidade de realizar a comunicação entre povos, ou homem e máquina. Um exemplo de
comunicação entre o homem e o computador é a linguagem de programação, as quais são
linguagens compostas por símbolos finitos, propriedades, estruturas e relacionamentos.
Essas especificações são definidas a partir de modelos matemáticos que possuem
regras para realizar o reconhecimento de uma linguagem específica, e viabilizaram a estrutura
sistemática para a construção de analisadores léxicos e sintáticos, no qual teve um grande
avanço no desenvolvimento de compiladores e interpretadores utilizando técnicas para a
integridade e validação das linguagens artificiais.
As linguagens formais são mecanismos representados por modelos matemáticos para
demonstrar seus formalismos, padrões e estruturas nas quais uma dada linguagem deverá

6
seguir para ser formalizada e reconhecida. Este procedimento é realizado por uma estrutura
lógica utilizada para realizar o reconhecimento e a produção de todas as cadeias de caracteres
(sentenças) que uma linguagem pode conter. Esta estrutura é demonstrada a partir de sistemas
geradores e reconhecedores, onde os sistemas geradores são representadas por gramáticas,
responsáveis pela produção das palavras a partir de um alfabeto de uma linguagem e os
sistemas reconhecedores, responsáveis por verificar se uma determinada entrada, ou seja,
sequência de caracteres, pertence ou não a uma Linguagem (SCHEFFEL, 2011).
2.2 Conceitos Básicos
As linguagens formais são definidas a partir da junção de símbolos definidos por um
alfabeto finito. Um símbolo é uma representação abstrata de um átomo ou caracter de um
alfabeto, sendo que os símbolos mais utilizados são os romanos e dígitos representados por
(a,b,c,0,1,2,3,4,5…). A partir destes símbolos, é possível formar cadeias que fazem parte de
uma linguagem. Um exemplo da representação do conjunto de símbolos ”a,b,c” podem ser
formadas os conjuntos de símbolos ou caracteres como, a, b, c, aa, bb, cca, abc, acb, abc,..., e
assim por diante.
Um alfabeto é o conjunto finitos de símbolos para a formalização de uma cadeia, na
qual representa uma linguagem, e sua notação é dada por V = {a,b,c,d..z}. Um exemplo de
um alfabeto é o dicionário da língua portuguesa, onde o alfabeto é formado a partir da
concatenação de símbolos que formam sentenças (palavras) válidas para a formalização de
linguagem. Apesar deste alfabeto conter uma quantidade finita de cadeias, é possível formar
infinitas outras cadeias com os símbolos utilizando seu alfabeto, mas essas cadeias não fariam
sentido para a linguagem, sendo que a mesma possui regras gramaticais onde cada palavra ou
sentença possui um significado para a formalização de uma frase ou conjunto de sentenças.
Cadeias ou sentenças são as reproduções de um alfabeto. Uma sentença ou cadeia
somente poderá ser construída a partir de um alfabeto definido. Como exemplo do alfabeto V
= {a.b.c.d.e} é possível construir N cadeias como, abd, acc, ee, cae.
Toda cadeia possui um tamanho denotado por |w|, e o seu tamanho é formado pela
quantidade de símbolos em que a cadeia é composta, com o exemplo do alfabeto V, a cadeia
|abc| possui o tamanho 3, ou seja |abc| = 3. Uma cadeia vazia ou de tamanho zero é
representada pelo símbolo ε ou Ø, formalmente |ε| = 0 (RAMOS, 2008).

7
A partir da formação de cadeias pode-se utilizar as concatenações para a geração de
novas cadeias válidas. O conceito de concatenação é dado pela forma da justaposição de duas
ou mais cadeias, da seguinte forma.
Considere as seguintes cadeias no Quadro 1:
Quadro 1: Cadeias de símbolos.
Fonte: Elaborado pelo autor.
A partir destes, pode-se formar uma nova cadeia, |ab| + |cd| = abcd, formalmente
denotada como |A| + |B| = AB, e deverá ser levado em consideração que a concatenação |AB|
≠ |BA| pois cada uma destas cadeias formam resultados diferentes, seguindo o exemplo do
Quadro 2:
Quadro 2: Conjunto de cadeias
O caso em que |AB| = |BA| somente é válido quando existir a concatenação de duas
cadeias sendo que uma delas é vazia |ε| = 0, dado no exemplo a seguir:
Considere as seguintes cadeias:
A = |ε| e B = |abc|, então |AB| = |BA|, pois independente da posição da cadeia para a
concatenação o resultado da nova cadeia será o mesmo, |AB| = |BA| = |abc|.
Por fim, entende-se como a potenciação de uma cadeia representada por |w|n
onde N é
a repetição da cadeia para uma reprodução seguindo o exemplo do Quadro 3 (RAMOS,
2008).
Quadro 3: Potenciação de cadeias.
A = |ab| e B = |cd|
|AB| = |abcd|
|BA| = |cdab|
a1
= a
a2
= aa
a3
= aaa

8
2.3 Linguagens
As linguagens são sistemas de comunicação utilizadas para a interação entre humanos.
Desta forma, as linguagens podem ser representadas de forma verbal e não verbal, a partir de
um idioma, língua ou dialeto, com o objetivo de transmitir informações a outro ser ou objeto.
(SANTIAGO-ALMEIDA, 2011, p. 442).
As linguagens não são importantes somente para a comunicação do dia-dia entre os
humanos. No entanto, além das linguagens naturais, as linguagens artificiais são utilizadas
para a comunicação entre homem-máquina por profissionais da área da matemática ou da
computação. Desta forma, as linguagens tem uma importância muito grande, pois são a partir
delas que os humanos conseguem comunicar-se com os computadores e desenvolver novos
softwares e novas tecnologias nesse segmento.
A partir da padronização sintática e de estruturas, poderá ser desenvolvido uma
linguagem formal para uma comunicação. Um exemplo são as linguagens de programação de
computador como C, PHP, Java, etc. Através dessas linguagens, é possível, a partir delas,
informar para um computador quais comandos deverão ser executados. No entanto, isso só é
possível porque existe um formalismo da linguagem escrita, desenvolvida através de modelos
matemáticos.
Sendo assim, ressalta-se que as linguagens formais são formadas por um conjunto
finito ou infinito de cadeias finitas, e estas cadeias são formadas pela concatenação e
justaposição de símbolos pertencentes de um alfabeto, obedecendo um conjunto de regras
estabelecidas.
Na Figura 1, são demonstradas as interações entre os conceitos de símbolos, cadeias e
linguagem, sendo que os símbolos são elementos de um alfabeto, nos quais pertencem a uma
sequência de cadeias, e estas cadeias ou o conjunto delas, formam elementos de uma
linguagem, dado que uma linguagem é formada por um conjunto de cadeias.

9
Figura 1: Símbolo, alfabeto, cadeia da linguagem
Fonte: RAMOS (2008).
Resumindo, formalmente, as linguagens são um conjunto de cadeias de símbolos
finitos denotado por um alfabeto V, que pertencem ao conjunto de símbolos V*, onde são
possíveis todas as cadeias do alfabeto, denotado por V ⊂ V*, seguindo o exemplo:
V = {a,b,c} então V* = V + {ε}, resultando em {ε, a, b, c}. V pode ser representado de forma
positiva, sendo V+
= V - {ε}, resultando somente em {a, b, c}, não podendo gerar cadeias
vazias (RAMOS, 2008).
Também é possível realizar a junção de duas ou mais linguagens para a formalização
de uma nova linguagem, onde todas as cadeias geradas pela união das linguagens sejam
válidas para a nova linguagem, dado o exemplo a seguir:
Dado um alfabeto ∑, poderá ser gerado um novo alfabeto ∑1
= {a’ | a’ ∈ ∑} e ∑2
=
{a” | a” ∈ ∑} , então gera-se uma nova linguagem L = ∑1
U ∑2
, resultando em L = {a’, a”}
(GRZEGORZ, 1997).
Ressalta-se que além dos símbolos permitidos em toda a linguagem, esta possui regras
de sintaxe, padrões e estruturas que devem ser seguidas para que seja possível gerar cadeias
(sentenças) válidas para a linguagem. Para isso, existem dispositivos ou sistemas que realizam
a geração de cadeias finitas, onde obrigatoriamente deverá gerar somente e qualquer cadeia
válida pertencente a uma linguagem a partir do seu alfabeto.

10
Estes dispositivos são chamados de sistemas geradores e são representados por
gramáticas. A definição de gramática é dada como “Estudo dos elementos de uma língua, tais
como sons, formas, palavras, construções e recursos expressivos”. Outra definição pode ser
entendida como “Conjunto das regras e das normas para o uso de uma língua.” (SANTIAGO-
ALMEIDA,2011, p. 359), ou seja, a gramática é um conjunto de definições de regras e
sintaxe para a formalização de palavras de uma determinada língua.
2.4 Gramáticas
Na computação, as gramáticas são formuladas a partir de modelos matemáticos nas
quais contém as regras para a geração das sentenças válidas para uma linguagem.
As gramáticas são basicamente constituídas de símbolos terminais e não terminais
definidas pelo conjunto de V = Σ ∪ N. Os símbolos terminais são denotados por Σ, que
definem o conjunto de símbolos que constituem as produções, ou seja o alfabeto, na forma de
Σ = {a,b,c}. Os terminais normalmente são representados por letras minúsculas, dígitos, e
caracteres especiais.
Os símbolos não terminais, definido por N = V - Σ são símbolos estáticos utilizados
para realizar a substituição ou justaposição de um terminal para a formalização de uma
sentença, sendo N = {S, A, B, C}, N sempre será composto pelo símbolo inicial {S} da
gramática. Os símbolos não terminais são representados pelas letras maiúsculas (RAMOS,
2008).
Formalmente, uma gramática G pode ser definida como uma quádrupla, da seguinte
forma: G = (N, Σ, P ,S) , onde:
V = O conjunto de símbolos não vazios de símbolos quaisquer, terminais e não terminais.
N = Conjunto de símbolos não terminais.
Σ = Conjunto de símbolos terminais, denotado como alfabeto da linguagem.
P = Conjunto de produções que podem ser geradas a partir das regras gramaticais da
linguagem. São entendidas como as regras da linguagem.

11
S = Símbolo pertencente ao conjunto dos não terminais, utilizado como o símbolo inicial da
gramática.
Uma produção P é formada pela seguinte notação α⟶β, em que α ∈ (N x Σ) e β ∈
V*, sendo α uma produção de β, onde α pertence a (N x Σ) e β pertence a V* ou V + {Ԑ}. A
produção de α é formada por regras da gramática da linguagem (RANGEL,1999).
2.5 Tipos de Linguagens
A evolução das linguagens se tornou mais abrangente no final da década de 1950, na
qual o linguista Noam Chomsky publicou um artigo relacionado às linguagens formais, em
que se tratava da classificação hierárquica das linguagens, separando-as por nível de
complexidade, além do desenvolvimento da representação sistemática das linguagens com o
objetivo de desenvolver um formalismo para as classificações propostas por Chomsky
(RAMOS, 2009).
O desenvolvimento do trabalho de Chomsky foi importante para o desenvolvimento
das linguagens artificiais, que a partir de suas classificações e modelos de implementação,
seria mais simples o desenvolvimento de um tipo de linguagem, diminuindo a complexidade
para o seu desenvolvimento.
A classificação das linguagens conhecida como Hierarquia de Chomsky, ocorre
através de 4 tipos de linguagens, enumeradas por 0, 1, 2 e 3, em ordem decrescente de
complexidade, conforme representa-se:
 0 - Linguagens Enumeráveis Recursivamente
 1 - Linguagens Sensíveis ao Contexto
 2 - Linguagens Livres ao Contexto
 3 - Linguagens regulares

12
O número relacionado a cada classificação refere-se a posição hierárquica que é
composta pelos quatro tipos de linguagens. Na Figura 2 pode-se visualizar sua hierarquia.
Figura 2: Relação hierárquica entre as classes de linguagens da Hierarquia de Chomsky
Fonte: COSTA, MENESES, UBER (2008).
Na Figura 2 da hierarquia de Chomsky, é possível perceber que a linguagem do tipo 0
é composta por todas as outras 1, 2 e 3 Linguagens. Desta forma, a linguagem enumerável
recursivamente fornece suporte a todas as outras linguagens, e assim sucessivamente, até a
linguagem regular que possui somente suporte para gerar e reconhecer linguagens regulares.
2.5.1 Linguagens Enumeráveis Recursivamente - Tipo 0
As linguagens enumeráveis recursivamente são aceitas por um único dispositivo reconhecedor
conhecido como máquina de Turing de fita infinita, na qual não possui limitação de memória.
Através desse tipo de linguagem, considerando seu reconhecedor, é possível realizar o
reconhecimento de linguagens mais abrangentes e complexas. Esse tipo de linguagem é
denominada como “recursivamente enumerável” devido suas sentenças serem contabilizadas
ou enumeradas por um mecanismo M cujo o objetivo é validar suas sentenças. Este processo
pode ser realizado somente por uma máquina de Turing, na qual possui uma fita que permite a
manipulação dos símbolos para a direita e para a esquerda.
Para considerar uma linguagem L enumerável, o seu alfabeto deve pertencer à Σ*,
sendo L ⊆ Σ*, onde uma máquina de Turing M deverá enumerar a linguagem L, obtendo uma
máquina de Turing que aceita a linguagem E, denotando da forma E(M) ⊆ Σ* (RAMOS,
2009).

13
Como a linguagem recursivamente enumerável é irrestrita, é possível desenvolver
gramáticas irrestritas que representam de forma estruturada uma linguagem do tipo 0. Uma
gramática é considerada irrestrita quando nenhuma regra adicional é dada a gramática, ou
seja, as regras gramaticais deverão ser somente sobre a formalização de suas sentenças.
Formalmente, as gramáticas irrestritas são representadas por (V ∪ Σ)+
⇾ (V ∪ Σ)* .
Este formato permite que o lado esquerdo da gramática possa gerar regras em que V seja no
mínimo uma variável com a união de (Σ - ε), e ao lado direito da gramática possa ser gerada
qualquer regra que contenha uma variável V em conjunto ao alfabeto Σ, podendo conter ou
não uma cadeia vazia |ε| (PRADO, 2007).
Um exemplo simples para ser demonstrado a estrutura de uma gramática para uma
linguagem recursivamente enumerável é dada a seguir:
Seja L = {an
bn
cn
| n ≥ 0}, então para uma gramática irrestrita G = ({S,C}, {a,b,c},S,P)
apresenta-se no Quadro 4 o exemplo da gramática:
Quadro 4: Gramática irrestrita.
Onde w = a3
b3
c3
seja uma cadeia a ser produzida, então a seguinte produção poderá
ser realizada da seguinte forma, apresentada no Quadro 5 (PRADO, 2007):
Quadro 5: Produção de uma gramática irrestrita.
P{S ⇾ abc
ab ⇾ aabbC
Cb ⇾ bC
Cc ⇾ cc}
S ⇾ abc ⇾ aabbCc ⇾ aaabbCbCc ⇾ aaabbbCCc ⇾ aaabbbCcc ⇾ aaabbbccc.

14
2.5.1.1 Máquina de Turing
As máquinas de Turing além de serem utilizadas como sistemas geradores de
linguagens recursivamente enumeráveis, também são utilizadas como sistemas
reconhecedores, em que MT A é equivalente a MT B, ou seja, a cadeia gerada por A deve ser
reconhecida e aceita por B.
Para que uma cadeia w gerada por A seja aceita pela máquina de Turing B, o símbolo
inicial deve ser compatível com o conjunto de símbolos iniciais da configuração de B e o
símbolo final deve atingir um estado final da fita, caso contrário, a máquina B não irá aceitar a
sentença, sem parar de se movimentar, além de alguns casos ficar em loop infinito.
Formalmente, uma máquina de Turing é dada por M = (Q, Σ, Г, δ, q0, F) onde
(HOPCROFT, 2002):
Q = Conjunto finitos de estados.
Σ = Alfabeto finito de entrada.
Г = Alfabeto finito da fita.
δ = Funções de transição.
q0 = Estado inicial da máquina.
F = Conjunto de estados finais de aceitação.
No exemplo da Figura 3, o símbolo inicial da fita da máquina de Turing é dado por
⇾, e o símbolo final seguido por β. O cabeçote de leitura poderá movimentar-se para
esquerda ou para a direita, para realizar a leitura da fita pelas funções de transição. A fita irá
conter um conjunto finito de símbolos do alfabeto Г , cujo o objetivo é realizar o
reconhecimento da entrada Σ.
Figura 3: Máquina de Turing com fita ilimitada.

15
As funções de transição são definidas formalmente por δ(q, X), onde q é o estado do
símbolo X, em que cada função de transição é representado pela tripla (p, Y, D) , sendo
δ(q, X) = (p,Y,D), em que:
p = Próximo estado pertencentes a Q.
Y = Símbolo que substituirá X na fita.
D = Direção para o próximo estado da máquina, sendo elas: direita ou esquerda.
2.5.2 Linguagens Sensíveis ao Contexto - Tipo 1
As linguagens sensíveis ao contexto possuem a característica na qual seu contexto de
execução, existem dependências de outras produções relacionadas para que uma sentença seja
validada, justificando o nome de “Sensível ao Contexto” (RAMOS, 2009). Um contexto pode
ser definido como “Conjunto das partes que compõem um texto como um todo. 2. Conjunto
de circunstâncias que permitem compreender um fato” (SANTIAGO-ALMEIDA,2011, p.
201), ou seja, da forma como as produções são construídas são necessárias outras sentenças
ou parte delas da gramática para a validação correta da sentença em questão.
Na estrutura das gramáticas sensíveis ao contexto, não possui a restrição de que em
seu lado esquerdo seja formado apenas por símbolos não terminais, pois ambos os lados da
gramática poderão conter símbolos terminais e não terminais. No entanto, este tipo de
gramática exige que em seu lado esquerdo contenha no mínimo um símbolo não terminal, e
que o lado direito possua uma quantidade de símbolos maior ou igual ao seu lado esquerdo
(RAMOS, 2009).
O Conceito de linguagens sensíveis ao contexto é muito importante e utilizado em
validações sintáticas. Como por exemplo, em validações de declaração de variáveis, funções e
expressões aritméticas, pois em seu contexto de declaração, é necessário de outras sentenças
pertencentes a gramática para que uma sentença faça sentido ou seja validada.

16
Uma abordagem simples sobre este tipo de gramática e suas dependências pode ser
demonstrado no Quadro 6:
Quadro 6: Gramática de uma linguagem sensível ao contexto.
No exemplo da gramática G¹, é perceptível que se trata de uma gramática simples cujo
o objetivo é validar expressões aritméticas básicas, além do que, a sentença deverá ser
composta por outras sentenças em seu contexto para que seja válida.
Para demonstrar a gramática G1
acima, será utilizado uma árvore de derivação que irá
validar a sentença “((a * b) / a) - b” conforme Figura 4.
Figura 4: Árvore de derivação
Na derivação da árvore demonstrada na Figura 4 em cada nó folha tem-se o resultado
da sentença, em cada último nó folha da árvore.
A gramática G1
possui somente o não terminal E em seu lado esquerdo, porém este
tipo de gramática permite terminais em seu lado esquerdo. Uma demonstração de uma
gramática completa sensível ao contexto e algumas produções é dada a seguir:
G1
= E ⇾ E + E | E * E | E - E | E / E | (E) | a | b

17
Seja a gramática G2
= ({a,b,c,S,B,C},{a,b,c},P,S), com a produção do Quadro 7:
Quadro 7: Gramática sensível ao contexto com produções
É possível ter algumas variações apresentadas no Quadro 8, sendo (RAMOS, 2009):
Quadro 8: Derivação de uma gramática sensível ao contexto.
2.5.2.1 Máquina de Turing com Fita Limitada
Além das linguagens recursivamente enumeráveis, as linguagens sensíveis ao contexto
também utilizam a máquina de Turing como dispositivo reconhecedor, porém este tipo de
máquina de Turing possui a fita limitada, ou memória limitada, contendo o tamanho da fita
com o mesmo tamanho da entrada mais duas células contendo marcadores de início e fim.
Formalmente, uma máquina de Turing com fita limitada é dada pela seguinte forma:
M = (Σ , Q, δ, q0, F, V, <, >), sendo (MENEZES, 2011):
Σ = Alfabeto de símbolos de entrada.
Q = Conjunto de estados da máquina.
δ = Função de transição.
q0 = Elemento pertencente ao conjunto de Q, que define o estado inicial.
F = Elemento pertencente ao conjunto de Q, ue define o estado final
P = {S ⇾ aSBC,
S ⇾ aBC,
CB ⇾ BC
aB ⇾ ab
bB ⇾ bb
bC ⇾ bc
cC ⇾ cc}
w1
= aBC ⇾ abC ⇾ abc
w2
= aSBC ⇾ aaBCBC ⇾ aaBBCC ⇾ aabBCC ⇾aabbCC ⇾ aabbcC ⇾ aabbcc

18
V = Alfabeto auxiliar.
< = Símbolo marcador de início da fita.
> = Símbolo marcador de fim da fita.
A Figura 5 apresenta a máquina de Turing com fita limitada.
Uma máquina de Turing M possui uma entrada w = {An
, Bn
, Cn -1
| n = 2} para ser
validada. Para isso a máquina de Turing terá como base a entrada w = {AABBC}. Pode-se
observar que a fita limitada representada na Figura 5, possui dois caracteres a mais nos
extremos da fita, os quais definem o início e o fim da fita. Devido a isso a máquina de Turing
é chamada de máquina de Turing com fita limitada, pois a máquina possui uma quantidade
limitada de posições de memória para validar uma sentença. Esta limitação é utilizada para a
máquina obter o controle de início e fim do reconhecimento de uma entrada.
Figura 5: Máquina de Turing com fita limitada.
A parir da leitura da fita da máquina de Turing com fita limitada, este tipo de máquina
pode realizar o reconhecimento de sentenças definidas pelas linguagens sensíveis ao contexto.
2.5.3 Linguagens Livres de Contexto - Tipo 2
As linguagens livres de contexto definida por Chomsky, vieram inicialmente para
formalizar as Linguagens naturais como Português e Inglês, porém cientistas concluíram que
as linguagens naturais são mais complexas que a classe das linguagens livres de contexto.
De qualquer forma, essa classe de linguagem despertou o interesse da área da
Computação, pois a partir da estrutura sistemática das linguagens do tipo 2, foi perceptível a
sua utilização para a validação sintática e desenvolvimento de reconhecedores de linguagens
artificiais, como linguagens de programação (RAMOS, 2009).

19
Para que uma linguagem seja definida como livre de contexto, as dependências
deverão ocorrer somente em outros trechos relacionados a sentença. Desta forma, a validação
de uma sentença poderá depender de outros não terminais da gramática, em que em um não
terminal possui uma parte de uma expressão e outro estado possui a outra parte da expressão
que deverá ser validada, sem a necessidade de conter as duas partes em um mesmo não
terminal, definido como contexto.
O exemplo da gramática G¹ dado anteriormente para uma linguagem sensível ao
contexto, pode ser demonstrado da forma que para validar uma sentença com parênteses, é
necessário em seu mesmo contexto de validação conter um parêntese de abertura e
fechamento. No entanto, para a linguagem livre de contexto isso não ocorre, pois sua estrutura
gramatical não é compatível com este caso.
Logo após a definição das linguagens livre de contexto, surgiu a notação BNF
(Backus-Naur Form), na qual teve um papel importante para o desenvolvimento das
representações de gramáticas livres de contexto, pois a partir desta notação, as representações
gramaticais ficaram de fácil compreensão. Isso ocorreu pelo fato de que seus símbolos não
terminais são substituídos por notações conhecidas como metalinguagem delimitados pelos
símbolos “< >”. O exemplo da notação BNF (Backus Naur Form) a seguir é dado para a
representação de uma linguagem livre de contexto a partir da notação BNF (Backus Naur
Form) (RAMOS, 2009).
Notação BNF¹ apresentada no Quadro 9:
Quadro 9: Notação Backus Naur Form.
Fonte: RAMOS (2009).
O exemplo da notação BNF (Backus Naur Form) demonstra a utilização de linguagens
livres de contexto para a validação sintática de uma frase.
<frase> ⇾ <sujeito> <verbo> <complemento>
<sujeito> ⇾ O homem | A mulher
<verbo> ⇾ leu | escreveu
<complemento> ⇾ um <adjetivo> livro
<adjetivo> ⇾ ótimo | péssimo

20
A estrutura sistemática das gramáticas livres de contexto possui a regra de que em seu
lado esquerdo poderão conter somente símbolos não-terminais, e em seu lado direito,
qualquer símbolo pertencente a Σ ⋃ N (terminais). Formalmente a uma gramática livre de
contexto é definida pela quádrupla G = (N, Σ, P, S).
Para o exemplo de validações de expressões matemáticas demonstrada para as
linguagens sensíveis ao contexto anteriormente, é possível construir uma gramática com o
mesmo objetivo seguindo as regras de gramáticas livres de contexto.
Considere a gramática G do Quadro 10:
Quadro 10: Gramática de uma linguagem livre de contexto.
Considerando a sentença a * (a + a), a seguinte derivação é realizada no Quadro 11:
Quadro 11: Derivação de uma gramática livre de contexto.
A diferença das dependências das gramáticas entre linguagens sensíveis ao contexto e
livres de contexto são perceptíveis neste exemplo, pois para a construção da sentença válida
para este caso, depende de outras partes (estados) da gramática não pertencentes do mesmo
contexto.
E ⇾ T + E | T
T ⇾ F * T | F
F ⇾ (E) | a
E ⇾ T ⇾ F * T ⇾ a * T ⇾ a * F ⇾ a * (E) ⇾ a * (T + E) ⇾ a * (F + E) ⇾ a * (a + E) ⇾
a * (a + T) ⇾ a * (a + F) ⇾ a * (a + a).

21
2.5.3.1 Autômato de Pilha
O dispositivo utilizado para o reconhecimento das linguagens livres de contexto são os
autômatos com pilha. Uma pilha pode ser entendida como uma estrutura de dados com
capacidade ilimitada cujo o objetivo é adicionar e remover símbolos do alfabeto que pertence
a linguagem. Estes símbolos são manipulados com o conceito de LIFO (Last In, First Out).
Para que uma linguagem seja aceita por um autômato de pilha, a pilha deverá estar
vazia e em seu estado inicial, todo o processo de leitura da sentença deverá ser executada a
partir das funções de transição. Ao final da leitura, a pilha deverá estar vazia e em um dos
seus estados finais, caso a sentença seja válida para a linguagem.
Formalmente, um autômato de pilha é dado pela sétupla (HOPCROFT, 2002):
P = (Q, Σ, Г, δ, q0, Z0, F) sendo:
Q = Conjunto finito de estados, semelhantes aos estados de um autômato finito.
Σ = Conjunto finito de símbolos de entrada.
Г = Alfabeto de pilha finito, sendo o conjunto de símbolos com permissão para serem
inseridos na pilha.
δ = Funções de transições do autômato.
q0 = Estado inicial do autômato.
Z0 = Símbolo de início da pilha.
F = Conjunto de estados de aceitação ou estados finais.
A Figura 6, demonstra um exemplo funcionamento de um autômato de pilha, seguindo
os seguintes passos:
Figura 6: Um autômato de pilha é essencialmente um autômato finito com uma estrutura de pilha.
Fonte:HOPCROFT (2002).

22
O autômato inicia-se no estado q0, realizando a leitura do primeiro símbolo. Após, é
verificado se existe uma função de transição para o mesmo, e caso exista, o símbolo é inserido
na pilha “push”, e o próximo símbolo é lido. Este processo é repetido até o final da sentença
de entrada, e todo o processo de push na pilha é realizado no estado q0 do autômato de pilha.
Caso não exista nenhuma função de transição para o símbolo lido, a sentença é rejeitada.
Após realizar a leitura da pilha o autômato irá automaticamente para o estado q1. Este
estado tem o objetivo de fazer o processo reverso do estado q0, gerando o reverso da palavra
inserida na pilha para validar a sentença com o autômato.
Com a pilha carregada, lê-se o primeiro símbolo da pilha. Neste momento as funções
de transição são verificadas. Caso exista uma transição, o símbolo é removido da pilha “pop”
e o próximo símbolo da pilha é lido. Este processo é realizado até o fim da pilha. Se a palavra
reversa da pilha é lida pelo autômato e a pilha estiver vazia, a sentença será válida, caso
contrário será rejeitada (HOPCROFT, 2002).
2.5.4 Linguagens Regulares - Tipo 3
A linguagem regular ou linguagem do tipo 3, é linguagem mais simples da hierarquia
de Chomsky, sendo a única linguagem da hierarquia que possui somente suporte para ela
mesma. Diferente das linguagens do tipo 0, 1, e 2, onde a linguagem do tipo 0 do possui
suporte para as linguagens 1, 2 e 3, a linguagem 1 possui suporte para 2 e 3 e a linguagem 3
somente para ela mesma.
As linguagens regulares não possuem um nível alto de complexidade, sendo que seus
algoritmos e autômatos são de fácil implementação para os sistemas geradores e
reconhecedores. Entretanto, esse tipo de linguagem possui algumas limitações, e uma delas é
que esse tipo de linguagem não possui suporte para o controle de balanceamento de símbolos,
como o exemplo do controle de abertura e fechamento de parênteses. Portanto, este tipo de
linguagem não poderá ser utilizada para a validação de expressões aritméticas, assim como as
linguagens de programação.

23
Os dispositivos utilizados para geração e reconhecimento das linguagens regulares
são, autômatos finitos, expressões regulares e gramáticas regulares, e cada um destes sistemas
utilizam uma estrutura diferente de para gerar e reconhecer uma LR (MENEZES, 2011).
As expressões regulares são uma forma de representação das linguagens regulares. A
sua representação é dada a partir de formalismos, pré-definidos da linguagem denominados de
metalinguagem. Estes formalismos utilizam os conceitos básicos de concatenação e união e
podem construir e validar qualquer sentença pertencente à uma linguagem regular.
Outra forma para representar as linguagens regulares são as gramáticas regulares. As
gramáticas regulares que implementam as linguagens regulares utilizam os conceitos básicos
de gramáticas apresentadas neste capítulo. Contém uma estrutura baseada em símbolos
terminais e não terminais, e possuem a regra que em seu lado esquerdo deverá conter somente
por símbolos não terminais, e em seu lado direito poderá ser composto por símbolos terminais
e não terminais e cadeias vazias, seguindo a regra de substituição de não terminais por
terminais a partir das regras definidas na gramática.
2.5.4.1 Autômatos Finitos
Os autômatos finitos são compostos por um conjunto finitos de estados, no qual é
composto obrigatoriamente por um estado inicial, um ou mais estados finais e funções de
transição, as quais possuem o objetivo de mover o autômato de um estado para outro a partir
de uma transição δ pré-definida por símbolos do alfabeto. Uma função de transição é
composta de estado de origem, estado de destino e um conjunto de símbolos pertencentes ao
alfabeto da linguagem.
As sentenças construídas a partir deste tipo de autômato, será composta
obrigatoriamente pelo conjunto do alfabeto definido pela linguagem regular, obedecendo as
regras de geração compostas pelas funções de transição.

24
2.6 Considerações Finais do Capítulo
Neste capítulo, foi possível compreender o que são as linguagens formais, suas
representações e seu funcionamento. Com base na hierarquia de Chomsky foram apresentados
os tipos de linguagens, seus objetivos e formalismos, além das possíveis gramáticas, e
conceitos aplicados em cada tipo de linguagem.
A pesquisa realizada para o desenvolvimento deste capítulo teve grande importância
para obter o conhecimento teórico relacionado a linguagens formais e autômatos, sendo que
estes conceitos são essenciais para o desenvolvimento deste trabalho.
Os conceitos e representações das Linguagens Regulares como gramáticas regulares,
expressões regulares e autômatos finitos serão abordadas no próximo capítulo, visando que
estes serão base para o desenvolvimento da ferramenta proposta neste trabalho.

25
3 LINGUAGENS REGULARES
Este capítulo apresenta os conceitos e as representações das linguagens regulares ou
linguagem do tipo 3, a construção de Autômatos finitos a partir de gramáticas regulares para a
validação de sentenças. Além destes conceitos, serão apresentadas ferramentas existentes que
implementam os conceitos de linguagens formais.
Considerando a sua facilidade (comparando aos outros tipos de linguagens) de
implementação e utilização, as linguagens regulares possuem várias aplicabilidades
importantes para a computação. Como exemplos da análise léxica no processo de análise de
compiladores e interpretadores de linguagens de programação e utilização de expressões
regulares para reconhecimento de padrões de strings, validações de campos de telas em
softwares e editores de textos.
Para que um compilador ou interpretador possa validar uma linguagem de
programação, este deverá passar por três tipos de análises, sendo elas análise léxica, análise
sintática e análise semântica.
As linguagens regulares são utilizadas na análise léxica, na qual possui o objetivo de
validar as palavras “Tokens” da linguagem, verificando as sentenças a partir da
implementação de um autômato ou algoritmo para a validação dos lexemas. Para que estes
lexemas sejam reconhecidos, o analisador léxico consulta uma tabela de tokens, conhecida
como tabela de símbolos, na qual é composta por todas as palavras reservadas da linguagem,
além do alfabeto disponível para criação de identificadores, como variáveis, nomes de
funções etc., lembrando que o processo da análise léxica não valida a sintaxe, somente os
lexemas de um código fonte.

26
3.2 Representação
As linguagens regulares possuem duas formas de representações, sendo dois tipos de
dispositivos que permitem gerar uma linguagem regular: expressões regulares e as gramáticas
regulares, além do autômato finito que permite reconhecer uma LR.
As expressões regulares são compostas pelo alfabeto da linguagem e pelos meta-
caracteres. Os meta-caracteres tem o objetivo de informar qual operação deverá ser obedecida
em conjunto com os símbolos definidos por uma expressão. Como exemplo, cita-se uma
sequência de dígitos, padrões que deverão ser seguidos por uma string, concatenações e
composições de substrings que deverão estar presente em uma entrada de dados a ser validada
por uma expressão regular.
Com a facilidade de sua implementação, as expressões regulares são utilizadas para
validar e-mails, datas, números de IPs, endereços de internet, dentre outros dados que deverão
seguir um padrão.
A representação de uma gramática regular pode ser dada a partir de uma sentença. A
gramática G(L) é construída para validar a sentença: W = {ab = v[i] * c}. Esta sentença é
representada na Figura 7 e demonstra as sentenças w¹, w², w³, w4
. Cada da parte sentença é
derivada pelas produções da gramática G(L) para verificar se a sentença W completa é válida
a partir de uma gramática regular.
Sendo G(L) em que seu alfabeto Σ = {a, b, c, i, v, [, ], *, =}, com a seguinte gramática
regular apresentada no Quadro 12:
Quadro 12: Gramática regular.
Pode-se dizer que todas as ocorrências w¹, w², w³, w4
pertencem a L pois obedecem às
regras da gramática do Quadro 13:
S → aS | bS | cS | iS | vS | [S | ]S | *S | =S | ε

27
Quadro 13: Regras de uma gramática regular.
Figura 7: Lexemas de uma expressão.
O formalismo de expressões regulares e gramáticas regulares serão abordadas no
próximo subcapítulo.
As linguagens regulares utilizam os autômatos finitos para realizar o seu
reconhecimento. Estes autômatos são constituídos por uma estrutura de diagrama o qual é
composto pela representação dos estados e funções de transições, construídos a partir de uma
gramática regular.
3.3 Expressões Regulares
As expressões regulares é outra alternativa para representar as linguagens regulares,
onde um alfabeto Σ de uma linguagem regular deverá seguir as seguintes regras (RAMOS,
2008).
1 - ∅ é um conjunto regular sobre Σ;
2 - {ǫ} é um conjunto regular sobre Σ;
3 - {ζ}, ∀ ζ ∈ Σ, é um conjunto regular sobre Σ, se X e Y são conjuntos regulares
sobre Σ, então também são conjuntos regulares sobre Σ, em que:
3.1 - (X);
w¹ = S → aS → abS → ε, então w¹ = {ab}
w² = S → =S → ε, então w² = {=}
w³ = S → vS → v[S → v[iS → v[i]S → ε, então w³ = {v[i]}
w4
= S → *S → *bS → ε, então w4
= {*b}

28
3.2- X ∪ Y ;
3.3 - X · Y , também denotado XY ;
3.4 - X ∗
As expressões regulares utilizam os conceitos básicos de operações de concatenação e
união em seus formalismos. O exemplo abaixo demonstra estes conceitos a partir de uma
expressão simples com a e b demonstradas no Quadro 14 (MENEZES, 2011):
Quadro 14: Regras de expressões regulares.
Fonte: MENEZES (2011).
Portanto a expressão (a + b)* (aa + bb) corresponde à seguinte linguagem do Quadro
15 (MENEZES, 2011):
Quadro 15: Conjunto de cadeias de uma expressão regular.
Analisando os conceitos de expressões regulares, é perceptível que as expressões
regulares utilizam basicamente conceitos básicos da teoria dos conjuntos da matemática, pois
com estes conceitos, é possível criar e manipular strings para que um padrão dado por uma
regra de expressão regular seja seguida.
As expressões regulares são constituídas pelo alfabeto da linguagem e meta-caracteres.
Os meta-caracteres são utilizadas para definir as regras que uma sentença deverá obedecer,
portanto, para obter uma expressão regular é necessário que a mesma contenha símbolos
pertencentes a um alfabeto, constituída por uma ou mais regras de um padrão denotado pelos
meta-caracteres, conforme Tabela 1:
a e b denotam { a } e { b }, respectivamente,
a + b denota { a } ∪ { b } = { a, b }
(a + b) * denota {a, b} *
aa e bb denotam { a } { a } = { aa } e { b }{ b } = { bb }
(aa + bb) denota { aa } ∪ { bb } = { aa, bb }
(a + b) * (aa + bb) detona { a, b }* { aa, bb }
{aa, bb, aaa, abb, baa, bbb, aaaa, aabb, abaa, abbb, baaa, babb, bbaa...}

29
Tabela 1: Lista de meta-caracteres de expressões regulares.
Meta-caracteres Nome Função
. Ponto Um caractere qualquer
[... ] Lista Lista de caracteres permitidos
[^ ] Lista Negada Lista de Caracteres proibidos
? Opcional Zero ou um
* Asterisco Zero, um ou mais
+ Mais Um ou mais
{n,m} Chaves De n até m
^ Circunflexo Início da linha
$ Cifrão Fim da linha
b Borda Início ou fim de palavra
c Escape Torna literal o caractere c
| Ou Ou um ou outro
(...) Grupo Delimita um grupo de caracteres
1…9 Retrovisor Texto casado nos grupos 1...9
Fonte: JARGAS (2012).
A partir de um alfabeto em conjunto com os meta-caracteres é possível gerar algumas
expressões, conforme exemplo do Quadro 16 (JARGAS, 2012):
Quadro 16: Exemplo de expressão regular.
Fonte: JARGAS (2012).
n[ãa]o gera {não, nao}
<[BAP]> gera {<B>, <A>, <P>}
[A-Za-z] gera qualquer palavra com letras maiúsculas e minúsculas
[0-9] gera qualquer número.
(www.) ?zz. com gera {www.zz.com, zz.com}
((((a)b)c)d)-1 = 1,2,3,4 gera {abcd-1 =abcd,abc,ab,a}
[a-z]+{2}abc +[A-Z] gera qualquer sentença iniciando com letras minúsculas, contendo
em sua sequência duas ocorrências de abc terminando com letras maiúsculas.
[a-z ^[bcdef]] gera qualquer palavra do alfabeto minúsculo que não possuem a sequência
“bcdef”.

30
3.4 Gramáticas Regulares
As gramáticas regulares, como mencionada anteriormente, é uma das representações
disponíveis para implementar uma linguagem regular.
As gramáticas regulares são compostas por uma estrutura de símbolos terminais, não
terminais, estados e regras de produções.
Detalhadamente, para a construção das gramáticas, algumas notações deverão ser
seguidas para não causar ambiguidade entre símbolos iguais com sentidos diferentes. Admite-
se que os símbolos não terminais deverão ser representados em letras maiúsculas, símbolos
terminais deverão ser representados por letras minúsculas, dígitos e/ou caracteres especiais.
A estrutura entre o lado esquerdo e direito da gramática deverá ser dividida por →, o
símbolo que caracteriza um elemento vazio deverá ser escrito por épsilon {ε}. A divisão entre
as possíveis produções em um estado deverá ser dividido por um pipeline |.
Dando continuidade, para cada não terminal da gramática, uma nova linha deverá ser
criada, representada da forma (Estado → Regras de Produções), cada estado deverá conter
uma ligação com outro estado pertencente a gramática, gerando uma estrutura lógica, com
todas as possibilidades de produções de uma linguagem.
Destaca-se que as gramáticas regulares, conforme sua descrição, segue o formalismo
geral das gramáticas descritas no capítulo anterior. No entanto, as gramáticas regulares
herdaram características importantes das linguagens regulares, ou seja, permite um único
símbolo não terminal do lado esquerda da gramática, e para cada não terminal, um conjunto
de regras que ficam do lado direito da gramática composto por um símbolo terminal e um não
terminal, um terminal ou épsilon, seguindo a notação G = (N, Σ, P ,S) (MENEZES, 2011).
O processo de execução de uma gramática acontece da seguinte forma: O seu início é
dado a partir do estado S, onde a partir deste, deverá ser verificado as possíveis escolhas de
símbolos terminais ao seu lado direito. Ao escolher um símbolo, o mesmo virá em conjunto
com um não terminal identificando o novo estado que deverá ser transitado.

31
Neste novo estado, o seu símbolo deverá ser substituído por uma das produções de seu
próprio estado corrente, podendo ficar no mesmo estado ou ser transitado para um novo
estado definido em conjunto com o símbolo terminal escolhido. Este processo de substituição
deverá ser repetido, seguindo as regras de produções da gramática, até o último símbolo da
sentença. Destaca-se que existem casos em que ao escolher uma produção de um estado, o
mesmo poderá estar contido somente por um único símbolo não terminal, e nestes casos
nenhuma substituição é realizada, somente a transição de estados é executada.
A partir da gramática G = ({A, B, C}, {a, b, c}, P, S) é possível ser construída a
seguinte estrutura, com o exemplo do Quadro 17:
Quadro 17: Estrutura da gramática regular.
A partir da estrutura acima, é perceptível que para cada estado ou linha da gramática é
possível visualizar as suas produções e transições entre os estados, como exemplo, será
verificado uma possível derivação de uma sentença:
Seja w¹ = {abbbcacc}, a construção desta sentença pode ser derivada da seguinte
forma a partir da gramática G do Quadro 18:
Quadro 18: Derivação da gramática regular.
Para atingir o resultado, a substituição de símbolos não terminais é realizada por um
novo símbolo terminal, até chegar ao fim da sentença, através de derivação.
S → aA | bA | cA
A → aB | bB | cB
B → aC | bC | cC
C → aA | bB | cB | ε
S → aA → abB → abbC →abbbB → abbbcC → abbbcaB → abbbcacC → abbbcacc

32
Ao realizar a derivação de uma sentença a partir de uma gramática, o processo das
produções é executado de forma implícita. Formalmente, uma produção P na qual pertencente
a uma gramática regular G é representada da seguinte forma:
Dada uma gramática G ({S, A, B}, {a, b}, P, S) é possível gerar a Tabela 2 de
produções P, onde {qf} representa o estado final:
Tabela 2: Transições construídas a partir das produções.
Produção (P) Transição δ
S ⟶ aA δ(S, a) = {A}
A ⟶ bB δ(A, b) = {B}
B ⟶ aA δ(B, a) = {A}
A ⟶ ε δ(A, ε) = {qf}
As transições da Tabela 2 podem ser visualizadas na Figura 8, através do autômato. O
processo de construção do autômato será apresentado posteriormente:
Figura 8: Autômato finito construído a partir de uma gramática regular.
Fonte: Baseado em MENEZES (2011).
3.5 Autômatos Finitos
Os computadores são baseados em máquinas de estados, onde a partir de um modelo
de estados, o hardware (processador) possa executar os procedimentos de um programa ou
parte de um código. Nas linguagens formais, como exemplo as gramáticas regulares, através
da validação de sentenças numa gramática regular, pode ser transformadas em um modelo de
estados chamado de autômato finito.

33
O objetivo de um autômato finito é representar um modelo computacional para definir
operações que uma máquina de estados deverá seguir, dando destaque para os compiladores,
nos quais utilizam autômatos para as análises de suas linguagens.
Os autômatos finitos são constituídos por estados, funções de transições,
configurações, estado inicial e estados finais. A partir deste modelo, é possível representar
uma gramática, no qual deverá obedecer às mesmas regras definidas na linguagem regular.
Os autômatos finitos são utilizados como reconhecedores de linguagens regulares.
Desta forma, uma gramática e um reconhecedor devem ser formalizados para gerar e
reconhecer uma linguagem. Neste contexto, um sistema gerador deve ser correspondente a um
sistema reconhecedor e um reconhecedor deve ser correspondente a um sistema gerador.
Ao contrário das gramáticas, um reconhecedor não pode construir regras na realização
do seu processo, pois seu modelo já é definido a partir das regras de uma gramática. Os
estados de um autômato são interligados a partir das funções de transição que permite realizar
a movimentação entre os estados para validar as sentenças formadas por símbolos de uma
alfabeto.
Formalmente, um autômato finito é definido por M = (Σ, Q, δ, q0, F) em que:
1) Σ = É o alfabeto de símbolos de entrada do autômato. Refere-se aos símbolos
terminais, do autômato;
2) Q = Refere-se ao conjunto de estados possíveis do autômato.
3) δ = Conjunto das possíveis funções de transições do autômato, em que a partir da
leitura de um novo símbolo quais as possibilidades em que um novo estado pode ser
alcançado.
4) q0 = define o estado inicial do autômato.
5) F = É um subconjunto de estado de Q, sendo F ⊂ Q, os estados de F são os possíveis
estados finais do autômato (MENEZES, 2011). Para que um autômato seja construído a partir
de uma gramática regular G = (N, Σ, P ,S) , as seguintes considerações deverão ser lavadas:
1) Todos os símbolos não terminais N da gramática deverão ser os estados Q do
autômato, sendo: N = Q.
2) Todo o alfabeto Σ da gramática deverá ser reconhecida pelo autômato.

34
3) Todas as produções P da gramática deverão estar contidas nas funções de transição δ
do autômato, sendo P = δ.
4) O símbolo inicial S da gramática deverá ser o estado inicial q0 do autômato.
5) Todos os estados possíveis de finalização para o reconhecimento de uma sentença de
uma gramática deverão estar contidos nos estados finais F do autômato.
Todo autômato possui um estado inicial q0. Este estado por sua vez, possui funções de
transição para outros estados, q1, q2, q3..., em que cada função de transição possui um
conjunto de símbolos finitos do alfabeto da linguagem para realizar os movimentos para
outros estados. As funções de transição são definidas por δ: Q x Σ ⇾ Q, a partir deste existem
N funções parciais dadas por δ(p, a) = q, onde p é um estado, a é o símbolo lido e q é o novo
estado. Para que uma sentença seja válida, ao final da sua leitura o autômato deverá estar no
seu estado final. Este conceito permite a finalização de uma análise de uma entrada para o
reconhecedor.
De forma simples, um autômato pode ser representado inicialmente pela Figura 9,
onde o mesmo é composto por dois estados, desligado e ligado representados por um círculo.
A sua função de transição é chamada de “pressionar”, em que ao ser executada, o autômato
muda de estado de desligado para ligado e vice-versa. Inicialmente, a flecha “início”
determina que o estado inicial deste autômato é o estado desligado, sendo obrigatoriamente ao
início de sua execução, estar em seu estado inicial. Neste caso, os dois estados poderão ser
estados finais, terminando o processo em ambos para a sua aceitação (HOPCROFT, 2002).
Figura 9: Um autômato finito que modela um interruptor liga/desliga.
Fonte: HOPCROFT (2002).
O processo de transformação da gramática para o autômato deverá ser realizado a
partir de uma tabela das possíveis transições entre os símbolos não terminais e terminais da
gramática, demonstrada pela Tabela 3 do exemplo G¹.

35
A tabela de transição de estados é montada da forma que, em sua primeira coluna
deverá estar contido todos os símbolos não terminais da gramática, denominados de estados
do autômato.
As colunas seguintes deverão estar separadas pelos possíveis símbolos terminais da
gramática. Destaca-se que o reconhecimento dos possíveis estados finais do autômato, que
poderão ser definidos quanto existir uma ocorrência de ε ou nos casos em que a linha da
gramática, possui a ocorrência de um símbolo terminal sem o seu estado sucessor. Considere
a seguinte gramática como exemplo:
Exemplo de gramática regular G¹ apresentado no Quadro 19:
Quadro 19: Exemplo de gramática regular para uma tabela de transição.
A Tabela 3 é construída a partir da gramática G¹, identificando o estado inicial com o
símbolo e os estados finais por um asterisco (*) :
Tabela 3: Tabela de transições da gramática G¹
δ a b c
⇾S A C C
A A B B
B C B B
* C C D D
* D B D D
A partir da Tabela 3 da gramática regular G¹, o autômato da Figura 10 é construído
verificando as possíveis transições de estados com os símbolos da primeira linha da tabela.
S ⇾ aA | bC | cC
A ⇾ aA | bB | cB
B ⇾ aC| bB | cB
C ⇾ aC | bD | cD | ε
D ⇾ aB | bC | cD | ε

36
Figura 10: Autômato gerado pela tabela 3 da gramática G¹
No exemplo do autômato da Figura 11, a sentença then é utilizada para demonstrar as
transições realizadas pelo autômato para o seu reconhecimento, Desta forma, apresenta-se o
estado inicial q0, sendo que este define o estado inicial em que o autômato deverá iniciar. O
autômato finito da Figura 11 possui cinco estados {q0, q1, q2, q3, qf}, e para cada um deles, é
definido uma função de transição a partir de um símbolo lido. Neste caso, este autômato foi
construído para validar o lexema then que para cada leitura de um símbolo, o seu estado é
alterado para o próximo estado, formando a palavra “then”. Chegando ao seu estado final qf
obtém a sentença validada e o ciclo do autômato concluído.
Figura 11: Um autômato finito que modela o reconhecimento de then.
Fonte: Figura baseada em HOPCROFT (2002).
Entretanto, os autômatos finitos são classificados de AFD (Autômato Finito
Determinístico) e AFND (Autômatos Finitos Não Determinísticos), em que cada um possui
seus conceitos e características específicas, as quais são definidas na seção:

37
3.5.1 Autômatos Finitos Determinísticos (AFD)
A definição de Autômatos Finitos Determinísticos (AFD) é dada da forma em que o
autômato finito não possui a possibilidade de múltiplos estados a partir de um símbolo lido,
sendo que o conjunto de funções de transições δ do autômato são definidas por δ(q, X) =
(p,Y,D) em que p é composto por um único estado destino (MENEZES, 2011).
A Tabela 4 apresenta o caso em que cada transição de um estado Q é composta
somente por um único estado de destino, a partir de um símbolo lido Y. Seguindo o conceito
de que um estado corrente pode conter somente um estado de destino, a transição de S para A
a partir do símbolo a, representa a função de transição: δ(q, X) = (p,Y,D) em que: δ(S, a) =
(A,{a,b,c},D).
Tabela 4: Tabela da Autômato Finito Determinístico
δ a b c
⇾S A A B
A S B B
* B A B B
O Autômato Finito Determinístico da tabela 4 pode ser apresentado de forma visual a
partir do diagrama da Figura 12, sendo possível analisar que o autômato finito não possui
múltipla escolha de estados a partir de um símbolo lido.
Figura 12: Diagrama do autômato AFD.

38
3.5.2 Autômatos Finitos Não Determinísticos (AFND)
A definição de Autômatos Finitos Não Determinísticos (AFND) é dada da forma em
que este tipo de autômato finito possui a possibilidade de múltiplos estados a partir de um
símbolo lido, sendo que o conjunto de funções de transições δ do autômato são definidas por
δ(q, X) = (p,Y,D) em que p é composto por um ou mais estado destino (MENEZES, 2011).
A Tabela 5 apresenta o caso em que um estado Q do autômato possui múltiplas
escolhas de estados a partir de um símbolo lido Y. Desta forma, pode-se observar que a partir
da leitura do símbolo a do estado S, o autômato possui duas possibilidades: A e B para a
transição. Esta função de transição é representada por: δ(q, X) = (p,Y,D) em que: δ(S, a) =
({A,B},{a,b,c},D). Observa-se que o conjunto dos próximos estados p é composto por A e B,
sendo p = {A,B}.
Tabela 5: Tabela da Autômato Finito Não Determinístico
δ a b c
⇾S A,B A S
A S B B
* B A B B
O Autômato Finito Não Determinístico da Tabela 5 é representado pelo diagrama da
Figura 13. Pode-se observar que a partir do símbolo a do estado S, existem duas
possibilidades de escolha de estados, sendo A ou B para a transição.
Figura 13: Diagrama do autômato AFND.
Um Autômato Finito Determinístico AFD pode ser construído a partir de um
Autômato Finito não Determinístico AFND, através de técnicas de transformação que serão
abordadas no próximo tópico.

39
3.5.3 Transformação de Autômato Finito Não Determinístico (AFND) para Autômato
Finito Determinístico (AFD)
Um Autômato é classificado como Autômato Finito Não Determinístico (AFND)
quando o mesmo possui mais que um estado de destino p a partir de um símbolo lido em um
estado q. Dado formalmente por δ(q, X) = (p,Y ,D) , Y é um conjunto que possui dois ou mais
estados de destino a partir da leitura de um símbolo X em q. Este tipo de autômato possui a
possibilidade de uma sentença válida não ser reconhecida, pois o autômato poderá realizar a
leitura de um símbolo em que a função de transição δ possui mais que um estado Y de
destino, podendo escolher o estado incorreto para o reconhecimento de uma sentença que
poderia ser validada corretamente pelo autômato a partir de um caminho válido do autômato.
Para realizar o reconhecimento de uma sentença a partir de uma gramática que gera
um Autômato Finito Não Determinístico (AFND), é necessário a transformação para um
Autômato Finito Determinístico (AFD), em que o Autômato AFD seja equivalente ao
Autômato AFND.
Assim, M¹ = (Σ¹, Q¹, δ¹, q0¹, F¹) e M² = (Σ², Q², δ², q0², F²) onde M¹ = M², ou seja, M¹
→ AFND deve ser equivalente a M² → AFD. Esta transformação é realizada a partir de um
algoritmo chamado de construção de conjuntos com objetivo de construir todos os
subconjuntos dos conjuntos de estados de um Autômato Finito Não Determinístico (AFND)
M¹. Essa construção produz um Autômato Finito Determinístico = M² podendo realizar o
reconhecimento de todas as sentenças possíveis de M¹ (AHO; SETHI; ULLMAN, 1995).
Esta transformação deve ser executada da forma que:
A) Q² é um conjunto dos subconjuntos de Q¹. Dado conjunto de potência de Q¹, da forma
em que Q¹ tem n estados, então Q² terá 2n
estados, sendo que nem todos os novos
estados de Q² serão acessíveis a partir do estado inicial q0² de M².
B) Todo alfabeto Σ¹ Є Σ², ou seja, todo alfabeto de M¹ deve pertencer a M².

40
C) A função de transição de M² deve ser dada da forma que para cada conjunto C ⊆ Q¹
com uma entrada x Є Σ. Deve-se verificar o seguinte formalismo δ²(C, x) = ∪p em C
δ¹(p,x), sendo que o mapeamento de δ² (C,x) é a união dos estados que M¹ alcança a
partir de p com a entrada x.
Para as funções δ², deve ser verificado todos os estados de p em C para os
quais ∃ δ¹ (p, x) . Dessa forma, todos os estados que estão contidos em C que p
alcança a partir de uma função δ¹, devem formar um novo estado, em que p é o estado
corrente x é o símbolo Σ da função, e o subconjunto de C deverá ser o novo estado
formado pelos conjuntos de estados que a função δ¹ alcança.
D) O estado inicial q0¹ = q0², ou seja, o estado inicial de M¹ deverá ser o estado inicial
M².
E) O conjunto de estados finais de M² deverá ser formado pela regra em que C = C ∩ F ≠
∅ , ou seja, o conjunto dos estados finais deverá ser classificado da forma que um
subconjunto dos conjuntos dos estados de M² contém ao menos um estado F¹ de M¹.
Um exemplo de um Autômato Finito Não Determinístico (AFND) pode ser
visualizado na Tabela 6. A partir da leitura do símbolo b Є Y no estado A Є p, existem duas
possibilidades de estados de destinos, sendo Y = {A,B} , resultando na função de transição
δ(q, X) = (p,Y ,D) onde δ(A, a) = ({A,B},{b}, D).
Tabela 6: Tabela AFND
Δ a b c
⇾S A B A
A A A,B B
* B B B
A partir da Tabela 6, o diagrama do autômato é presentado na Figura 14. Observa-se
que a partir do estado A com a leitura do símbolo b existem dois caminhos {A,B} de destino,
classificando-o como um Autômato Finito Não Determinístico (AFND).

41
Figura 14: Diagrama do Autômato AFND para transformação
A Tabela 7 representa a transformação para Autômato Finito Determinístico (AFD) a
partir da Tabela 6, que representa um Autômato Finto Não Determinístico (AFND). Para a
montagem da Tabela 7 foram seguidos os seguintes passos:
A) A primeira linha da tabela que representa o estado S mantém-se original, pois será
a partir deste estado que será analisado as próximas transições para análise da
transformação.
B) Na segunda linha pode ser verificado que a partir do estado A com a leitura do
símbolo b existe uma função não determinística δ(A, a) = ({A,B},{b},D). Desta
forma, o conjunto dos estados de destino de A lendo b, e deverá formar um novo
estado (AB), apresentado na linha seguinte da tabela de transformação AFD.
C) Para a construção das funções de transição do novo estado AB, as transições dos
estados do seu subconjunto {A,B} deverão ser analisadas da seguinte forma:
O estado A do conjunto {A,B} possui o destino A com a leitura do simbolo a.
O estado B do conjunto {A,B} possui o destino B com a leitura do símbolo a.
Desta forma, o estado de destino de AB para leitura do símbolo a deverá ser o
conjunto de destacados de destinos do subconjunto de estados {A,B}, sendo AB.
Este passo é executado para todos os símbolos Σ da tabela de transformação,
observando que o mapeamento das funções de transição cria novos estados,
necessitando realizar o mapeamento de todos as funções de transição da tabela
para todos os novos estados encontrados.
D) A classificação de estados finais é destacada com o símbolo * (asterisco), onde os
novos estados deverão ser classificados como estado final quando o seu
subconjunto de estados possuir um estado final F da tabela de transição do

42
Autômato Finito Não Determinístico (AFND). Neste caso, o estado AB é final
pois o estado B que está em seu conjunto {A,B} é um estado final *B.
Tabela 7: Tabela de Transformação de AFND para AFD.
δ a b c
⇾S A B A
A A AB B
*AB AB AB B
* B B B
Após o processo de transformação do Autômato Finito Determinístico (AFND) para
Autômato Finito Determinístico (AFD) é necessário renomear os novos estados criados em
M², para posteriormente facilitar a construção do autômato. Desta forma, o nome dos estados
são definidos seguindo a ordem alfabética. No caso da Tabela 7, o nome do último estado do
conjunto de M¹ é B, então o novo estado AB de M² será renomeado para C, verificando que
todas as suas referências na tabela de transição de estados também devem ser renomeadas. A
Tabela 8 demonstra que o estado AB e suas referências foram renomeadas para C.
Tabela 8: Tabela de transformação AFD.
δ a b c
⇾S A B A
A A C B
*C C C B
* B B B
A partir da Tabela 8, a qual representa M², pode-se construir um Autômato Finito
Determinístico (AFD) representado na Figura 15.
A transformação de M¹ para M², cujo o formalismo é M¹ = (Σ¹, Q¹, δ¹, q0¹, F¹) e
M² = (Σ², Q², δ², q0², F²). Os Autômatos AFD e AFND são representados da forma
M¹ = ({a,b,c}, {S,A,B}, S, B) e M² = ({a,b,c}, {S,A,B,C}, S, {B,C}), onde M¹ é equivalente a
M², ou seja, todas as sentenças que M¹ reconhece, podem ser reconhecidas por M².

43
Figura 15: Autômato Finito Determinístico AFD.
Após a transformação do Autômato Finito Não Determinístico (AFND) para o
Autômato Finito Determinístico (AFD), as sentenças são reconhecidas sem as funções não
determinísticas encontradas no Autômato AFND, as quais podem ocasionar o não
reconhecimento correto de uma sentença válida para a Gramática Regular.
3.6 Ferramentas Para Linguagens Formais e Autômatos
Atualmente, existem várias ferramentas que implementam os conceitos das
Linguagens Formais e Autômatos. Estas ferramentas são desenvolvidas com o objetivo de
auxiliar no ensino-aprendizagem nos curso de ciência da computação ou facilitar o
entendimento sobre algum conceito específico da teoria da computação.
Embora existam várias ferramentas, cada uma delas possui suas características e
formas diferentes de solucionar um problema. A seguir será apresentado de forma sintetizada
as ferramentas atuais de Linguagens Formais e Autômatos e suas características.

44
3.6.1 Ferramenta VAS
A ferramenta VAS é uma ferramenta desenvolvida pelo acadêmico Jean Bovet para
conclusão de curso de ciência da computação da Universidade de San Francisco dos Estados
Unidos (BOVET, 2006).
A ferramenta é constituída pelas implementações de AFD, AFND , máquina de Turing
e transformação de AFND para AFD.
O objetivo da ferramenta constitui em construir autômatos graficamente para que o
usuário possa desenhar os estados do autômato e informar as funções de transição entre os
estados. Após a construção, o usuário poderá informar a sentença ser validada pelo autômato.
Neste contexto, a ferramenta é bastante intuitiva, sendo de fácil uso para a construção
de autômatos, entretanto, a ferramenta não possui a conversão de gramáticas regulares para
autômatos. Isso pode dificultar o entendimento teórico para acadêmicos iniciantes deste
conteúdo, sem compreender a construção de um autômato a partir de uma gramática. Na
Figura 16 é possível visualizar a interface gráfica da ferramenta.
Figura 16: Ferramenta VAS.
A Figura 16 demonstra um exemplo de um Autômato Finito Determinístico (AFD)
desenhado para a realização de testes de pesquisa da ferramenta VAS.
A ferramenta encontra-se disponível no repositório do GitHub¹.
¹GitHub: https://github.com/yurifw/Visual-Automata-Simulator

45
3.6.2 Ferramenta GAM
A ferramenta GAM (Ginux Abstract Machine) é uma ferramenta desenvolvida pelos
acadêmicos Anibal S. Jukemura, Hugo A. D. do Nascimento, Joaquim Q. Uchôa da
Universidade Federal de Goiás (UFG) para a apresentação de um artigo no XXV Congresso
da Sociedade Brasileira da Computação. A ferramenta foi desenvolvida para o apoio no
ensino-aprendizagem nos cursos de ciência da computação com as seguintes funcionalidades:
construção de autômatos AFD, AFND, transformação de AFND para AFD e minimização de
AFD (JUKEMURA, NASCIMENTO, UCHÔA, 2005).
A ferramenta GAM tem como objetivo construir autômatos para a validação de
entrada de dados. A ferramenta torna-se de fácil uso pois possui opções para construção do
autômato graficamente, podendo informar as funções de transição entre os estados, podendo
visualizar os símbolos correntes em que o autômato está validando no momento da execução.
No entanto, a ferramenta não possui a opção de construção de autômatos a partir de
gramáticas, sendo necessário o conhecimento de conversão de gramáticas regulares para
autômatos para a sua utilização. Na figura 17, é possível visualizar a interface gráfica da
ferramenta.
Figura 17: Ferramenta GAM
Fonte: JUKEMURA, NASCIMENTO, UCHÔA (2005).

46
A ferramenta GAM possui um recurso importante para compreender o funcionamento
do reconhecimento de sentenças, pois ela permite a análise passo a passo da sentença de
entrada, como demonstra a Figura 17 nesta seção.
A ferramenta GAM (Ginux Abstract Machine) não encontra-se disponível para
download.
3.6.3 Ferramenta JFLAP
A ferramenta JFLAP é mantida pela Comunidade de Computação da Universidade
Duke dos Estados Unidos, tendo a participação de vários acadêmicos, professores e
desenvolvedores em sua construção. Atualmente é uma das ferramentas mais completas já
desenvolvidas com implementações teóricas da computação, sendo elas: AFD, AFND,
expressões regulares, máquina de Turing, máquina de Mealy, máquina de Moore,
transformação de AFND para AFD, gramáticas, transformação de AFD para expressões
regulares e minimização de AFD (RODGER, FINLEY, 2006).
Por ser uma ferramenta completa, a mesma possui a funcionalidade que permite a
construção de autômatos a partir de gramáticas informadas pelo usuário, sendo que estes
autômatos podem ser utilizadas para validar a entrada de sentenças demonstrando a execução
do autômato em tempo real. No entanto, essa conversão fica um tanto abstrata para o usuário,
pois a tabela de conversão da gramática para o autômato não é demonstrada para o usuário em
sua construção. Na Figura 18 é possível visualizar a interface da ferramenta.
Figura 18: Ferramenta JFLAP.

Ferramenta para auxílio na aprendizagem de linguagens formais e autômatos

Ferramenta para auxílio na aprendizagem de linguagens formais e autômatos

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (17)

Semelhante a Ferramenta para auxílio na aprendizagem de linguagens formais e autômatos

Semelhante a Ferramenta para auxílio na aprendizagem de linguagens formais e autômatos (20)

Ferramenta para auxílio na aprendizagem de linguagens formais e autômatos