data: textos extraídos (outputs) dos 4 modelos OCR na RTX 6000 — 50 págs cada, p/ comparação de acurácia (CER/WER)

ocr_outputs/deepseek-ocr-2/page-01.md

@@ -0,0 +1,17 @@
+text[[234, 213, 805, 234]]
+Faculdade São Francisco de Assis – FSFA 
+
+title[[315, 380, 728, 398]]
+# APOSTILA DA DISCIPLINA 
+
+text[[428, 544, 613, 560]]
+Disciplina EAD 
+
+text[[326, 588, 717, 604]]
+Linguagens Formais e Autômatos 
+
+text[[397, 631, 645, 647]]
+Prof. Matheus Serpa 
+
+text[[430, 830, 610, 846]]
+Março de 2026.

ocr_outputs/deepseek-ocr-2/page-02.md

@@ -0,0 +1,36 @@
+sub_title[[138, 85, 297, 110]]
+## SUMÁRIO
+
+text[[138, 148, 909, 859]]
+1 Introdução às Linguagens Formais 5
+1.1 Símbolos, Alfabetos e Cadeias 5
+1.1.1 Prefixo, Sufixo e Subpalavra 6
+1.1.2 Exemplos de Cadeias 7
+1.2 Linguagens Formais e Fecho de Kleene 7
+1.3 Operações sobre Cadeias e Linguagens 8
+1.3.1 Representações de Linguagens 9
+1.3.2 Potência e Fecho de uma Linguagem 9
+1.4 A Hierarquia de Chomsky — Visão Geral 10
+1.5 Aplicações: Fases de um Compilador 10
+1.6 Lista de Exercícios 11
+2 Conceitos sobre Linguagens Formais 13
+2.1 Gramáticas Formais 13
+2.1.1 Exemplo de Gramática 14
+2.2 Derivação e Linguagem Gerada 14
+2.2.1 Árvore de Derivação 14
+2.3 Hierarquia de Chomsky 15
+2.3.1 Exemplos por Tipo 16
+2.3.2 Gramáticas Regulares: Linear à Direita e à Esquerda 17
+2.4 Operações sobre Linguagens e Fechamento 17
+2.5 Relação entre Gramáticas e Reconhecimentos 18
+2.6 Lista de Exercícios 19
+3 Linguagens Regulares e Autômatos Finitos Determinísticos 21
+3.1 Autômatos Finitos Determinísticos 21
+3.1.1 Função de Transição Estendida e Aceitação 22
+3.2 Representações de um AFD 22
+3.2.1 Segundo Exemplo: AFD para Cadeias Terminadas em ab 23
+3.3 Computação Passo a Passo 24
+3.3.1 Exemplo: AFD para Paridade de a's 24
+3.3.2 Estado Morto e Funções Parciais 25
+3.4 Propriedades das Linguagens Regulares 25
+3.5 Lista de Exercícios 26

ocr_outputs/deepseek-ocr-2/page-03.md

@@ -0,0 +1,38 @@
+text[[137, 81, 909, 914]]
+4 Autômatos Finitos Não-Determinísticos 28
+4.1 Definição Formal de AFN 28
+4.1.1 Exemplo: AFN para Cadeias Terminadas em ab 29
+4.1.2 Exemplo: AFN para Cadeias Contendo aba como Subpalavra 29
+4.2 Função de Transição Estendida e Aceitação 30
+4.2.1 Exemplo de Computação 30
+4.3 Equivalência AFN-AFD: Construção de Subconjuntos 31
+4.3.1 Exemplo de Conversão 31
+4.4 Vantagens do Não-Determinismo 32
+4.5 Lista de Exercícios 33
+5 Autômatos Finitos com Movimentos Vazios 35
+5.1 Definição Formal de AFN-ε 35
+5.2 Fecho-ε 36
+5.2.1 Exemplo: AFN-ε M7 36
+5.2.2 Exemplo: AFN-ε para a*b* ∪ c 37
+5.3 Função de Transição Estendida 37
+5.4 Eliminação de ε-Transições 38
+5.4.1 Exemplo de Eliminação 39
+5.5 Equivalência AFN-ε, AFN e AFD 39
+5.5.1 Aplicações Práticas dos AFN-ε 40
+5.6 Lista de Exercícios 41
+6 Expressões Regulares 43
+6.1 Definição Formal 43
+6.2 Precedência dos Operadores 44
+6.2.1 Exemplos de Expressões Regulares 44
+6.3 Leis Algébricas 45
+6.4 Teorema de Kleene: ER e Linguagens Regulares 47
+6.4.1 Construção de Thompson 47
+6.4.2 Limitações das Expressões Regulares 48
+6.5 Lista de Exercícios 49
+7 Linguagens Livres de Contexto 51
+7.1 Gramática Livre de Contexto 51
+7.1.1 Definição Formal 51
+7.1.2 Exemplo: L = {a^n b^n | n ≥ 0} 52
+7.2 Derivações e Árvores de Derivação 53
+7.2.1 Derivação Mais à Esquerda e Mais à Direita 53
+7.2.2 Árvore de Derivação 54

ocr_outputs/deepseek-ocr-2/page-04.md

@@ -0,0 +1,36 @@
+text[[140, 81, 910, 856]]
+7.3 BNF e Gramáticas Ambíguas 54
+7.3.1 Notação BNF 54
+7.3.2 Ambiguidade 55
+7.3.3 Recursão em Gramáticas 56
+7.4 Lista de Exercícios 56
+8 Simplificação de GLC e Formas Normais 58
+8.1 Etapa 1: Eliminação de Símbolos Inúteis 59
+8.1.1 Identificação de Variáveis Geradoras 59
+8.1.2 Exemplo 60
+8.2 Etapa 2: Eliminação de Produções Vazias 60
+8.2.1 Algoritmo 60
+8.2.2 Exemplo Detalhado 61
+8.3 Etapa 3: Eliminação de Produções Unitárias 61
+8.3.1 Algoritmo 61
+8.3.2 Exemplo Detalhado 62
+8.4 Forma Normal de Chomsky 62
+8.4.1 Definição e Algoritmo 62
+8.4.2 Exemplo de Conversão para FNC 63
+8.4.3 Forma Normal de Greibach 63
+8.5 Lista de Exercícios 64
+9 Autômatos com Pilha 66
+9.1 Definição Formal 66
+9.1.1 A Sêxtupla 66
+9.1.2 Operações na Pilha 67
+9.2 Função de Transição 67
+9.2.1 Formato 67
+9.2.2 Não Determinismo 68
+9.3 Critérios de Parada 68
+9.3.1 ACEITA, REJEITA e LOOP 68
+9.4 Exemplo: AP para  \( L = \{a^{n}b^{n} \mid n \geq 1\} \)  69
+9.4.1 Construção 69
+9.4.2 Processamento de aabb 69
+9.4.3 Processamento de entradas rejeitadas 70
+9.5 Visualização do Processamento 71
+9.6 Lista de Exercícios 71

ocr_outputs/deepseek-ocr-2/page-05.md

@@ -0,0 +1,39 @@
+text[[140, 81, 910, 920]]
+10 Construção de AP a partir de GLC 73
+10.1 Teorema e Construção Formal 73
+10.1.1 Enunciado 73
+10.1.2 Regras de Transição 73
+10.2 Exemplo:  \( L = \{a^{n}b^{n} \mid n \geq 1\} \)  74
+10.2.1 Gramática em FNC 74
+10.2.2 Processamento de aabb 75
+10.2.3 Correspondência entre derivação e processamento 75
+10.3 Poder Computacional dos AP 76
+10.3.1 AP Determinístico versus Não Determinístico 76
+10.3.2 Correspondência na Hierarquia 76
+10.4 Lista de Exercícios 77
+11 Propriedades das Linguagens Livres de Contexto 79
+11.1 Lema do Bombeamento para LLC 79
+11.1.1 Enunciado Formal 79
+11.1.2 Exemplo:  \( \{a^{n}b^{n}c^{n}\} \)  Não é LLC 80
+11.2 Propriedades de Fechamento 81
+11.2.1 Operações que Preservam LLC 81
+11.2.2 Tabela Comparativa 82
+11.3 Decidibilidade 82
+11.3.1 Problemas Decidíveis e Indecidíveis 82
+11.3.2 Tabela de Decidibilidade 83
+11.4 Linguagens Inerentemente Ambiguas 83
+11.4.1 Definição e Exemplo 83
+11.4.2 Posição das LLC na Hierarquia 84
+11.5 Lista de Exercícios 84
+12 Máquina de Turing e Hierarquia de Chomsky 86
+12.1 Definição Formal 86
+12.1.1 A 8-Tupla 86
+12.1.2 Estrutura da Fita 87
+12.2 Critérios de Parada 87
+12.2.1 ACEITA, REJEITA e LOOP 87
+12.2.2 Exemplo: MT para  \( \{a^{n}b^{n} \mid n \geq 1\} \)  88
+12.3 Tese de Church-Turing 89
+12.3.1 Enunciado e Significado 89
+12.4 Hierarquia de Chomsky Completa 90
+12.4.1 Os Quatro Tipos 90
+12.4.2 Tabela da Hierarquia 90

ocr_outputs/deepseek-ocr-2/page-06.md

@@ -0,0 +1,5 @@
+text[[140, 83, 905, 178]]
+12.4.3 Gramáticas Irrestritas 91
+12.4.4 Visão Geral dos Reconhecimentos 91
+12.5 Lista de Exercícios 92
+13 Referências 94

ocr_outputs/deepseek-ocr-2/page-07.md

@@ -0,0 +1,32 @@
+sub_title[[139, 87, 841, 110]]
+## 1 INTRODUÇÃO ÀS LINGUAGENS FORMAIS
+
+text[[136, 138, 907, 262]]
+A Teoria das Linguagens Formais é um dos pilares da Ciência da Computação. Desenvolvida inicialmente pelo linguista Noam Chomsky na década de 1950, seu objetivo original era formalizar o estudo das linguagens naturais. Posteriormente, verificou-se que os mesmos formalismos eram aplicáveis — e extremamente úteis — na descrição de linguagens artificiais, especialmente linguagens de programação e na construção de compiladores (MENEZES, 2011).
+
+text[[136, 266, 908, 432]]
+Compreender essa teoria permite ao profissional de computação entender os limites do que é computável, projetar linguagens de programação e construir ferramentas como compiladores, interpretadores e analisadores de texto. Conceitos dessa área são também aplicados em bioinformática, processamento de linguagem natural e verificação formal de sistemas (HOPCROFT; ULLMAN; MOTWANI, 2002). De maneira complementar, o domínio de conceitos algorítmicos básicos — como estruturas de dados, recurso e análise de complexidade — é um pré-requisito importante para a compreensão dos modelos formais estudados nesta disciplina (MEDINA; FERTIG, 2006).
+
+text[[136, 436, 908, 582]]
+Além dessas aplicações clássicas, a teoria das linguagens formais possui conexões profundas com a álgebra abstrata, a lógica matemática e a teoria dos grafos. O estudo de monoides livres, por exemplo, fornece uma base algébrica para a concatenação de cadeias, enquanto a lógica de segunda ordem sobre cadeias finitas corresponde exatamente às linguagens regulares (SIPSER, 2007). Essas conexões interdisciplinares tornam a área fundamental não apenas para a prática da computação, mas também para a pesquisa em ciência da computação teórica.
+
+sub_title[[138, 609, 555, 627]]
+## 1.1 Símbolos, Alfabetos e Cadeias
+
+text[[136, 647, 906, 706]]
+Um símbolo (ou caractere) é uma entidade abstrata básica, não definida formalmente. Letras, dígitos e caracteres especiais são exemplos de símbolos. Símbolos são os átomos a partir dos quais construímos todas as estruturas da teoria.
+
+text[[136, 710, 907, 770]]
+Um alfabeto, denotado  \( \Sigma \) , é um conjunto finito e não vazio de símbolos. A restrição de finitude é essencial: embora as linguagens possam ser infinitas, o conjunto de símbolos base é sempre finito. Exemplos clássicos:
+
+text[[138, 784, 433, 801]]
+•  \( \Sigma_{1}=\{a,b\} \)  — alfabeto binário;
+
+text[[138, 816, 542, 833]]
+•  \( \Sigma_{2}=\{0,1\} \)  — alfabeto dos dígitos binários;
+
+text[[138, 849, 717, 866]]
+•  \( \Sigma_{3}=\{a,b,c,\ldots,z\} \)  — 26 letras minúsculas do alfabeto romano.
+
+text[[138, 880, 906, 920]]
+A escolha do alfabeto depende do domínio de aplicação. Em computação, o alfabeto  \( \{0,1\} \)  é fundamental para representação binária; em linguagens de programação, o alfa-

ocr_outputs/deepseek-ocr-2/page-08.md

@@ -0,0 +1,44 @@
+text[[137, 85, 907, 144]]
+beto pode incluir letras, dígitos e símbolos especiais como +, ; e f. Independentemente do número de símbolos, a condição de finitude garante que possamos enumerar todos os elementos do alfabeto (MENEZES, 2011).
+
+text[[137, 148, 907, 272]]
+Uma cadeia (ou palavra) sobre  \( \Sigma \)  é uma sequência finita de símbolos de  \( \Sigma \) . A cadeia vazia, denotada  \( \varepsilon \) , não contém nenhum símbolo e desempenha papel análogo ao do zero na aritmética: é o elemento neutro da concatenação. O comprimento de uma cadeia w, denotado  \( |w| \) , é o número de símbolos que a compõem; em particular,  \( |\varepsilon| = 0 \) . A notação  \( |w|_{a} \)  indica o número de ocorrências do símbolo a em w. Exemplos sobre  \( \Sigma = \{a, b\} \) :  \( |abba| = 4 \) ,  \( |abba|_{a} = 2 \) ,  \( |abba|_{b} = 2 \) .
+
+text[[137, 276, 906, 336]]
+A n-ésima potência de uma cadeia w, denotada  \( w^{n} \) , é a concatenação de w consigo mesma n vezes:  \( w^{0} = \varepsilon \)  e  \( w^{n} = w \cdot w^{n-1} \) . Assim, para w = ab:  \( w^{2} = abab \)  e  \( w^{3} = ababab \) . A notação  \( a^{n} \)  representa n cópias do símbolo a.
+
+sub_title[[186, 350, 552, 366]]
+## Exemplo – Cadeias e Comprimentos
+
+text[[153, 378, 576, 397]]
+Seja \(\Sigma = \{0, 1\}\). Considere as seguintes cadeias:
+
+text[[154, 411, 538, 430]]
+•  \( w_{1}=0110 \) :  \( |w_{1}|=4 \) ,  \( |w_{1}|_{0}=2 \) ,  \( |w_{1}|_{1}=2 \) ;
+
+text[[154, 444, 529, 463]]
+•  \( w_{2}=111 \) :  \( |w_{2}|=3 \) ,  \( |w_{2}|_{0}=0 \) ,  \( |w_{2}|_{1}=3 \) ;
+
+text[[154, 477, 328, 496]]
+•  \( w_{3} = \varepsilon \) :  \( |w_{3}| = 0 \) .
+
+text[[153, 510, 888, 552]]
+Observe que  \( w_{1}^{2}=01100110 \)  e  \( |w_{1}^{2}|=2\cdot|w_{1}|=8 \) . De modo geral, vale a propriedade  \( |w^{n}|=n\cdot|w| \)  para qualquer cadeia w e inteiro  \( n\geq0 \) .
+
+sub_title[[139, 582, 495, 599]]
+## 1.1.1 Prefixo, Sufixo e Subpalavra
+
+text[[137, 613, 907, 672]]
+Dada uma cadeia w, dizemos que x é prefixo de w se w = xy; sufixo se w = yx; e subpalavra se w = yxz, para cadeias y, z adequadas. Essas noções são essenciais na análise léxica de compiladores (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+text[[137, 676, 940, 736]]
+Por exemplo, para w = abcb: os prefixos são  \( \varepsilon \) , a, ab, abc, abcb; os sufixos são  \( \varepsilon \) , b, cb, bcb, abcb; e as subpalavras incluem  \( \varepsilon \) , a, b, c, ab, bc, cb, abc, bcb, abcb. Um prefixo (ou sufixo) x é dito próprio se  \( x \neq w \)  e  \( x \neq \varepsilon \) .
+
+text[[137, 741, 907, 822]]
+Note que a cadeia vazia  \( \varepsilon \)  é prefixo, sufixo e subpalavra de qualquer cadeia w, e toda cadeia w é prefixo, sufixo e subpalavra de si mesma. Uma cadeia de comprimento n possui exatamente  \( n + 1 \)  prefixos (incluindo  \( \varepsilon \)  e w) e  \( n + 1 \)  sufixos. O número de subpalavras distintas pode ser menor que  \( \binom{n}{2} + n + 1 \)  devido a repetições (SIPSER, 2007).
+
+sub_title[[186, 837, 504, 854]]
+## Contagem de Prefixos e Sufixos
+
+text[[155, 866, 445, 884]]
+Para uma cadeia w com  \( |w| = n \) :

ocr_outputs/deepseek-ocr-2/page-09.md

@@ -0,0 +1,44 @@
+text[[155, 81, 567, 101]]
+- Número de prefixos (incluindo \(\varepsilon\) e \(w\)): \(n + 1\) 
+
+text[[155, 113, 490, 134]]
+- Número de prefixos próprios: \(n - 1\) 
+
+text[[155, 145, 560, 167]]
+- Número de sufixos (incluindo \(\varepsilon\) e \(w\)): \(n + 1\) 
+
+text[[155, 179, 483, 200]]
+- Número de sufixos próprios: \(n - 1\) 
+
+sub_title[[139, 227, 430, 247]]
+### 1.1.2 Exemplos de Cadeias 
+
+text[[139, 257, 907, 299]]
+Sobre \(\Sigma = \{a, b\}\): \(\varepsilon\), \(a\), \(b\) são cadeias de comprimento 0 ou 1; \(ab\), \(ba\), \(aa\), \(bb\) são cadeias de comprimento 2; \(abba\) e \(aabb\) são cadeias de comprimento 4. 
+
+text[[139, 299, 904, 343]]
+A Tabela [1.1] organiza as cadeias de comprimento 0 a 3 sobre o alfabeto \(\Sigma = \{a, b\}\), evidenciando que o número de cadeias de comprimento \(n\) é \(|\Sigma|^n = 2^n\). 
+
+table_caption[[227, 355, 817, 377]]
+Tabela 1.1: Cadeias sobre \(\Sigma = \{a, b\}\) organizadas por comprimento. 
+
+table[[139, 387, 905, 533]]
+<table>Comprimento<br/>nΣ<sup>n</sup>Cadeias01ε12a, b24aa, ab, ba, bb38aaa, aab, aba, abb, baa, bab, bba, bbb</table>
+
+sub_title[[139, 562, 655, 586]]
+## 1.2 Linguagens Formais e Fecho de Kleene 
+
+text[[139, 600, 907, 641]]
+O **fecho de Kleene** de \(\Sigma\), denotado \(\Sigma^*\), é o conjunto de todas as cadeias sobre \(\Sigma\), incluindo \(\varepsilon\): 
+
+equation[[380, 636, 666, 680]]
+\[ \Sigma^* = \bigcup_{i=0}^{\infty} \Sigma^i = \Sigma^0 \cup \Sigma^1 \cup \Sigma^2 \cup \dots \]
+
+text[[139, 686, 907, 750]]
+onde \(\Sigma^0 = \{\varepsilon\}\), \(\Sigma^1 = \Sigma\), e \(\Sigma^n\) é o conjunto das cadeias de comprimento \(n\). O **fecho positivo** \(\Sigma^+ = \Sigma^* - \{\varepsilon\}\) exclui a cadeia vazia. Note que \(\Sigma^*\) é sempre infinito e que \(|\Sigma^n| = |\Sigma|^n\) (SIPSER, 2007). 
+
+text[[139, 750, 909, 835]]
+Uma **linguagem formal** \(L\) sobre \(\Sigma\) é qualquer subconjunto de \(\Sigma^*\): \(L \subseteq \Sigma^*\). Essa definição é bastante geral: inclui desde a linguagem vazia \(\emptyset\) até \(\Sigma^*\) inteiro. A linguagem vazia \(\emptyset\) (nenhuma cadeia) difere de \(\{\varepsilon\}\) (contém exatamente a cadeia vazia). A Tabela [1.2] apresenta exemplos. 
+
+text[[139, 835, 907, 878]]
+A Figura [1.1] ilustra a relação entre o alfabeto \(\Sigma\), o fecho de Kleene \(\Sigma^*\) e uma linguagem \(L \subseteq \Sigma^*\), mostrando que toda linguagem é um subconjunto do universo de cadeias possíveis.

ocr_outputs/deepseek-ocr-2/page-10.md

@@ -0,0 +1,38 @@
+image[[350, 81, 700, 252]]
+ 
+
+image_caption[[169, 262, 870, 283]]
+<center>Figura 1.1: Relação entre \(\Sigma\), \(L\) e \(\Sigma^*\): toda linguagem \(L\) é um subconjunto de \(\Sigma^*\).</center> 
+
+table_caption[[325, 313, 720, 334]]
+Tabela 1.2: Exemplos de linguagens formais. 
+
+table[[137, 344, 907, 447]]
+<table>AlfabetoLinguagem \(L\)Exemplos{0, 1}{w | |w| é par}ε, 00, 01, 10{a, b}{a<sup>n</sup>b<sup>n</sup> | n ≥ 1}ab, aabb{a, b}{w | w = w<sup>R</sup>} (palíndromos)a, aba, abba</table>
+
+sub_title[[186, 476, 428, 497]]
+Distinção Fundamental 
+
+text[[155, 506, 460, 528]]
+É crucial distinguir três conceitos: 
+
+text[[155, 540, 705, 561]]
+- A linguagem vazia \(\emptyset\) não contém nenhuma cadeia: \(|\emptyset| = 0\). 
+
+text[[155, 574, 841, 595]]
+- A linguagem {ε} contém exatamente uma cadeia (a cadeia vazia): \(|\{ε\}| = 1\). 
+
+text[[155, 607, 760, 628]]
+- A cadeia vazia ε é um elemento (uma cadeia), não uma linguagem. 
+
+text[[155, 640, 852, 661]]
+Confundir esses conceitos é um dos erros mais frequentes em provas e exercícios. 
+
+sub_title[[137, 693, 655, 716]]
+1.3 Operações sobre Cadeias e Linguagens 
+
+text[[137, 730, 906, 814]]
+A **concatenação** de duas cadeias \(x\) e \(y\), denotada \(xy\), é a justaposição de seus símbolos. É associativa, possui \(\varepsilon\) como elemento neutro, mas **não** é comutativa. A **reversa** de \(w = a_1a_2\cdots a_n\), denotada \(w^R\), é \(a_n\cdots a_2a_1\); em particular, \(\varepsilon^R = \varepsilon\). Uma cadeia \(w\) com \(w = w^R\) é um **palíndromo** (SIPSER, 2007). 
+
+text[[137, 815, 905, 922]]
+Sobre linguagens, definem-se: **união** \(L_1 \cup L_2\), **concatenação** \(L_1L_2 = \{xy \mid x \in L_1, y \in L_2\}\), **interseção** \(L_1 \cap L_2\), **complemento** \(\overline{L} = \Sigma^* - L\) e **fecho de Kleene** \(L^* = \bigcup_{i=0}^\infty L^i\). Por exemplo, para \(L_1 = \{a, ab\}\) e \(L_2 = \{b, ba\}\): \(L_1 \cup L_2 = \{a, ab, b, ba\}\) e \(L_1L_2 = \{ab, aba, abb, abba\}\). Essas operações permitem construir linguagens complexas a partir de linguagens simples.

ocr_outputs/deepseek-ocr-2/page-11.md

@@ -0,0 +1,48 @@
+sub_title[[188, 87, 586, 105]]
+Exemplo – Operações sobre Linguagens 
+
+text[[155, 113, 717, 135]]
+Sejam \(L_1 = \{a, ab\}\) e \(L_2 = \{b, ba\}\) sobre \(\Sigma = \{a, b\}\). Calculemos: 
+
+text[[155, 147, 450, 168]]
+- **União:*- \(L_1 \cup L_2 = \{a, ab, b, ba\}\) 
+
+text[[155, 181, 576, 201]]
+- **Concatenação:*- \(L_1 \cdot L_2 = \{ab, aba, abb, abba\}\) 
+
+text[[155, 214, 670, 234]]
+- **Interseção:*- \(L_1 \cap L_2 = \emptyset\) (nenhum elemento em comum) 
+
+text[[155, 245, 386, 267]]
+- **Reversa:*- \(L_1^R = \{a, ba\}\) 
+
+text[[155, 280, 888, 322]]
+Observe que a concatenação \(L_1 \cdot L_2\) é obtida concatenando cada cadeia de \(L_1\) com cada cadeia de \(L_2\): \(a \cdot b = ab\), \(a \cdot ba = aba\), \(ab \cdot b = abb\), \(ab \cdot ba = abba\). 
+
+sub_title[[139, 351, 519, 371]]
+1.3.1 Representações de Linguagens 
+
+text[[139, 381, 902, 465]]
+Linguagens podem ser representadas por: (1) **enumeração** — listar todas as cadeias, viável apenas para linguagens finitas; (2) **compreensão** — descrever por propriedade, ex.: \(L = \{a^n b^n \mid n \ge 1\}\); (3) **gramáticas formais** — regras que geram as cadeias; (4) **autômatos** — máquinas que reconhecem as cadeias (MENEZES, 2011). 
+
+text[[139, 467, 905, 551]]
+Para cada classe na Hierarquia de Chomsky, existem formalismos geradores (gramáti-
+cas) e reconhecedores (autômatos) equivalentes. Essa dualidade é um dos resultados mais
+elegantes da teoria. Duas representações são **equivalentes** quando definem exatamente
+a mesma linguagem. 
+
+text[[139, 553, 905, 637]]
+A escolha da representação depende do objetivo: para especificar padrões de busca, expressões regulares são mais convenientes; para implementar reconhecedores, autômatos finitos são preferíveis; para descrever a sintaxe de linguagens de programação, gramáticas livres de contexto são o padrão (HOPCROFT; ULLMAN; MOTWANI, 2002). 
+
+sub_title[[139, 658, 580, 679]]
+1.3.2 Potência e Fecho de uma Linguagem 
+
+text[[139, 689, 904, 773]]
+A potência de uma linguagem é definida como \(L^0 = \{\varepsilon\} \in L^n = L \cdot L^{n-1}\) para \(n \ge 1\).
+O **fecho de Kleene** de \(L\) é \(L^* = \bigcup_{i=0}^\infty L^i\) e o **fecho positivo** é \(L^+ = \bigcup_{i=1}^\infty L^i\). Essas operações são fundamentais na definição de expressões regulares e na especificação de padrões em compiladores (SIPSER, 2007). 
+
+text[[169, 774, 870, 796]]
+Por exemplo, para \(L = \{a, ab\}\): \(L^0 = \{\varepsilon\}\), \(L^1 = \{a, ab\}\), \(L^2 = \{aa, aab, aba, abab\}\). 
+
+text[[139, 796, 904, 860]]
+Observe que \(L^+ = L \cdot L^*\), ou equivalentemente, \(L^* = \{\varepsilon\} \cup L^+\). Quando \(\varepsilon \in L\), temos \(L^* = L^+\), pois a cadeia vazia já está presente na potência \(L^1\). Caso contrário, \(L^*\) e \(L^+\) diferem apenas pela presença de \(\varepsilon\) (MENEZES, 2011).

ocr_outputs/deepseek-ocr-2/page-12.md

@@ -0,0 +1,35 @@
+sub_title[[138, 87, 692, 106]]
+## 1.4 A Hierarquia de Chomsky — Visão Geral
+
+text[[136, 125, 907, 205]]
+A Hierarquia de Chomsky classifica as gramáticas (e as linguagens que elas geram) em quatro tipos, do mais restrito ao mais geral. Cada tipo corresponde a um modelo computacional de reconhecimento com poder expressivo crescente (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+text[[136, 209, 907, 270]]
+A Figura 1.2 apresenta visualmente a relação de inclusão entre os quatro tipos. Cada classe está estritamente contida na classe superior, ou seja, existem linguagens em cada nível que não pertencem ao nível inferior.
+
+image[[317, 284, 723, 500]]
+
+
+figure_title[[137, 512, 906, 547]]
+Figura 1.2: Hierarquia de Chomsky: relação de inclusão estrita entre os quatro tipos de linguagens.
+
+sub_title[[185, 579, 544, 597]]
+## Resumo da Hierarquia de Chomsky
+
+text[[154, 606, 889, 646]]
+• Tipo 3 – Regulares: reconhecidas por autômatos finitos. Exemplos: identificadores, constantes numéricas.
+
+text[[154, 660, 888, 701]]
+• Tipo 2 – Livres de Contexto: reconhecidas por autômatos com pilha. Exemplos: expressões aritméticas, parênteses balanceados.
+
+text[[154, 715, 888, 755]]
+• Tipo 1 – Sensíveis ao Contexto: reconhecidas por autômatos linearmente limitados. Exemplo:  \( \{a^{n}b^{n}c^{n} \mid n \geq 1\} \) .
+
+text[[154, 769, 888, 810]]
+• Tipo 0 – Recursivamente Enumeráveis: reconhecidas por máquinas de Turing. Incluem linguagens para as quais não existe algoritmo de decisão.
+
+sub_title[[138, 842, 634, 863]]
+## 1.5 Aplicações: Fases de um Compilador
+
+text[[137, 880, 907, 920]]
+Um compilador traduz código-fonte de alto nível para linguagem de máquina. A teoria das linguagens formais fundamenta suas três principais fases de análise (HOPCROFT;

ocr_outputs/deepseek-ocr-2/page-13.md

@@ -0,0 +1,38 @@
+text[[138, 84, 409, 101]]
+ULLMAN; MOTWANI, 2002):
+
+text[[137, 121, 904, 161]]
+• Análise Lóxica: varre o código-fonte identificando tokens (palavras reservadas, identificadores, operadores). Baseia-se em linguagens regulares e autômatos finitos.
+
+text[[137, 176, 904, 215]]
+• Análise Sintática: verifica se a sequência de tokens obedece à gramática da linguagem. Baseia-se em linguagens livres de contexto e autômatos com pilha.
+
+text[[137, 230, 905, 269]]
+• Análise Semântica: verifica aspectos de significado, como compatibilidade de tipos e escopo de variáveis.
+
+text[[136, 288, 906, 369]]
+Autômatos finitos são úteis na modelagem de circuitos digitais e na análise léxica; gramáticas apoiam o reconhecimento de estruturas recursivas em linguagens de programação. Essas ferramentas teóricas são, portanto, indispensáveis na engenharia de compiladores modernos (SIPSER, 2007).
+
+text[[136, 373, 907, 476]]
+A Figura 1.3 ilustra as fases de análise de um compilador, mostrando como o código-fonte é processado sequencialmente. Cada fase utiliza formalismos distintos da teoria das linguagens formais: a análise léxica emprega autômatos finitos (Tipo 3), a análise sintática emprega gramáticas livres de contexto (Tipo 2), e a análise semântica utiliza técnicas que transcendem as linguagens livres de contexto (RAMOS; NETO; VEGA, 2009).
+
+image[[138, 491, 911, 556]]
+
+
+figure_title[[194, 570, 850, 587]]
+Figura 1.3: Fases de análise de um compilador e os formalismos associados.
+
+text[[136, 613, 907, 736]]
+Além das fases de análise, um compilador realiza fases de síntese (geração e otimização de código). A tabela de símbolos, que armazena informações sobre identificadores, é uma estrutura compartilhada entre todas as fases. Ferramentas como lex (análise léxica) e yacc (análise sintática) automatizam a geração dessas fases a partir de especificações formais, demonstrando a aplicação direta da teoria na prática (DIVERIO; MENEZES, 2008).
+
+sub_title[[138, 765, 424, 783]]
+## 1.6 Lista de Exercícios
+
+text[[159, 802, 905, 840]]
+1. Qual foi o propósito inicial que motivou o desenvolvimento da Teoria das Linguagens Formais?
+
+text[[196, 857, 543, 874]]
+(a) Investigar hardware para Assembly.
+
+text[[196, 883, 497, 900]]
+(b) Analisar sistemas de arquivos.

ocr_outputs/deepseek-ocr-2/page-14.md

@@ -0,0 +1,62 @@
+text[[196, 84, 905, 124]]
+(c) Desenvolver teorias relacionadas às linguagens naturais, verificando depois aplicabilidade em linguagens artificiais.
+
+text[[195, 133, 525, 151]]
+(d) Melhorar velocidade de execução.
+
+text[[196, 160, 462, 178]]
+(e) Projetar módulos de rede.
+
+text[[158, 193, 801, 211]]
+2. Quais são as três análises mais comuns realizadas por um compilador?
+
+text[[195, 226, 521, 244]]
+(a) Simbólica, lexical, interpretativa.
+
+text[[195, 253, 490, 271]]
+(b) Lóxica, sintática e semântica.
+
+text[[195, 281, 468, 299]]
+(c) Formal, gráfica, heurística.
+
+text[[195, 307, 498, 326]]
+(d) Recursiva, linear, exponencial.
+
+text[[196, 335, 552, 353]]
+(e) Convergente, divergente, otimização.
+
+text[[159, 368, 758, 386]]
+3. Como funcionam as fases de análise léxica, sintática e semântica?
+
+text[[195, 401, 905, 440]]
+(a) Lóxica identifica erros lógicos; sintática atribui significado; semântica separa variáveis.
+
+text[[195, 449, 905, 488]]
+(b) Lóxica garante operações corretas; sintática converte para máquina; semântica verifica CPU.
+
+text[[195, 497, 905, 538]]
+(c) Lóxica varre código identificando tokens; sintática verifica estrutura (gramática); semântica checa significado (tipos corretos).
+
+text[[195, 546, 905, 586]]
+(d) Lóxica trata formatação; sintática traduz para Assembly; semântica decide plataformas.
+
+text[[196, 594, 905, 633]]
+(e) Lóxica substitui instruções; sintática monta declarações; semântica ignora símbolos.
+
+text[[159, 649, 820, 667]]
+4. Qual é o papel dos autômatos finitos e das gramáticas em compiladores?
+
+text[[195, 682, 652, 700]]
+(a) Autômatos não têm aplicação em análise léxica.
+
+text[[195, 709, 905, 749]]
+(b) Autômatos são úteis na modelagem de circuitos digitais e análise léxica; gramáticas apoiam reconhecimento de estruturas recursivas.
+
+text[[196, 758, 716, 776]]
+(c) Gramáticas foram substituídas por técnicas semânticas.
+
+text[[195, 786, 650, 804]]
+(d) Autômatos e gramáticas são um único conceito.
+
+text[[196, 812, 655, 831]]
+(e) Ambos só aparecem em linguagens de alto nível.

ocr_outputs/deepseek-ocr-2/page-15.md

@@ -0,0 +1,38 @@
+sub_title[[137, 88, 875, 110]]
+## 2 CONCEITOS SOBRE LINGUAGENS FORMAIS 
+
+text[[137, 137, 907, 263]]
+Neste capítulo, estudamos os mecanismos que permitem definir e gerar linguagens de maneira precisa: as gramáticas formais. Uma gramática é um conjunto finito de regras que especifica como construir todas as cadeias de uma linguagem, mesmo quando essa linguagem é infinita. Além disso, apresentamos a célebre Hierarquia de Chomsky, que classifica as gramáticas em quatro tipos fundamentais, cada um associado a um modelo computacional de reconhecimento (MENEZES, 2011). 
+
+text[[137, 265, 907, 348]]
+A Hierarquia de Chomsky organiza todo o estudo da disciplina e é um dos resultados mais importantes da ciência da computação teórica. Compreendê-la permite situar cada formalismo no contexto correto e entender o poder expressivo de cada classe de linguagens (SIPSER, 2007). 
+
+text[[137, 351, 907, 456]]
+Gramáticas formais foram inicialmente propostas por Noam Chomsky para modelar a estrutura das linguagens naturais, mas rapidamente se mostraram indispensáveis na descrição de linguagens de programação. A notação BNF (Backus-Naur Form), amplamente utilizada na especificação de linguagens como Algol, Pascal e C, é essencialmente uma gramática livre de contexto (HOPCROFT; ULLMAN; MOTWANI, 2002). 
+
+sub_title[[137, 483, 441, 504]]
+### 2.1 Gramáticas Formais 
+
+text[[137, 519, 904, 625]]
+Uma gramática formal é uma quádrupla \(G = (V, T, P, S)\), onde: \(V\) é o conjunto finito de variáveis (não-terminais); \(T\) é o conjunto finito de **terminais**, com \(V \cap T = \emptyset\); \(P\) é o conjunto finito de **regras de produção**; e \(S \in V\) é o **símbolo inicial**. Os terminais são os símbolos que aparecem nas cadeias finais; as variáveis são auxiliares no processo de geração (SIPSER, 2007). 
+
+text[[137, 627, 907, 668]]
+Cada regra tem a forma \(\alpha \to \beta\), onde \(\alpha\) contém ao menos uma variável. Quando uma variável \(A\) possui múltiplas produções, usamos a notação \(A \to \alpha_1 \mid \alpha_2 \mid \dots \mid \alpha_n\). 
+
+sub_title[[186, 682, 522, 700]]
+#### Componentes de uma Gramática 
+
+text[[156, 710, 585, 730]]
+Uma gramática \(G = (V, T, P, S)\) é composta por: 
+
+text[[156, 743, 888, 784]]
+- \(V\) — variáveis (não-terminais): símbolos auxiliares usados na geração. Convenção: letras maiúsculas \((S, A, B, \dots)\). 
+
+text[[156, 797, 888, 839]]
+- \(T\) — terminais: símbolos que compõem as cadeias finais. Convenção: letras minúsculas \((a, b, c, \dots)\) ou dígitos. 
+
+text[[156, 852, 848, 872]]
+- \(P\) — regras de produção: definem como substituir cadeias contendo variáveis. 
+
+text[[156, 885, 780, 906]]
+- \(S\) — símbolo inicial: variável a partir da qual toda derivação começa.

ocr_outputs/deepseek-ocr-2/page-16.md

@@ -0,0 +1,47 @@
+text[[155, 81, 888, 120]]
+A condição \(V \cap T = \emptyset\) garante que não há ambiguidade sobre a natureza de cada símbolo. 
+
+sub_title[[139, 145, 445, 165]]
+### 2.1.1 Exemplo de Gramática 
+
+text[[139, 177, 904, 218]]
+Considere \(G_1 = (\{S\}, \{a, b\}, P, S)\) com \(P = \{S \to aSb \mid ab\}\). Essa gramática gera \(L(G_1) = \{a^nb^n \mid n \ge 1\}\). Para derivar \(aaabb\): \(S \Rightarrow aSb \Rightarrow aaSb \Rightarrow aaabb\). 
+
+text[[139, 220, 904, 261]]
+Outra gramática \(G_2 = (\{S, A\}, \{a, b\}, \{S \to aAb, A \to aAb \mid \varepsilon\}, S)\) gera a mesma linguagem. Gramáticas que geram a mesma linguagem são ditas equivalentes. 
+
+sub_title[[187, 273, 594, 293]]
+#### Exemplo – Gramática para Palíndromos 
+
+text[[155, 302, 619, 323]]
+A gramática \(G_3 = (\{S\}, \{a, b\}, P, S)\) com produções: 
+
+equation[[415, 341, 630, 360]]
+\[S \to aSa \mid bSb \mid a \mid b \mid \varepsilon\]
+
+text[[155, 380, 884, 421]]
+gera a linguagem dos palíndromos sobre \(\{a, b\}\): \(L(G_3) = \{w \in \{a, b\}^* \mid w = w^R\}\). Derivação de \(abba\): 
+
+equation[[366, 424, 678, 441]]
+\[S \Rightarrow aSa \Rightarrow abSba \Rightarrow ab\varepsilon ba = abba\]
+
+text[[155, 455, 888, 496]]
+Note que as produções \(S \to a\) e \(S \to b\) geram palíndromos de comprimento ímpar, enquanto \(S \to \varepsilon\) gera palíndromos de comprimento par. 
+
+sub_title[[139, 526, 571, 549]]
+## 2.2 Derivação e Linguagem Gerada 
+
+text[[139, 565, 905, 648]]
+A **derivação** consiste na aplicação sucessiva de regras de produção a partir de \(S\). Dizemos que \(\alpha\) **deriva diretamente** \(\beta\) (\(\alpha \Rightarrow \beta\)) se \(\beta\) é obtida substituindo em \(\alpha\) uma ocorrência do lado esquerdo de alguma produção pelo respectivo lado direito. A notação \(\alpha \Rightarrow^* \beta\) indica zero ou mais passos de derivação (MENEZES, 2011). 
+
+text[[139, 650, 905, 714]]
+A **linguagem gerada** por \(G\) é \(L(G) = \{w \in T^* \mid S \Rightarrow^* w\}\), ou seja, todas as cadeias de terminais deriváveis a partir de \(S\). A cadeia \(w\) pertence a \(L(G)\) se e somente se pode ser obtida por uma sequência finita de aplicações de regras de produção. 
+
+text[[139, 714, 904, 799]]
+É importante distinguir entre **formas sentenciais** e **sentenças**. Uma forma sentencial é qualquer cadeia \(\alpha \in (V \cup T)^*\) tal que \(S \Rightarrow^* \alpha\); ela pode conter variáveis. Uma sentença é uma forma sentencial que pertence a \(T^*\), ou seja, não contém variáveis. Assim, \(L(G)\) é o conjunto de todas as sentenças deriváveis a partir de \(S\) (SIPSER, 2007). 
+
+sub_title[[139, 820, 419, 839]]
+### 2.2.1 Árvore de Derivação 
+
+text[[139, 852, 907, 913]]
+Para gramáticas livres de contexto (Tipo 2), cada derivação pode ser representada por uma **árvore de derivação** (ou árvore sintática). A raiz é o símbolo inicial \(S\), os nós internos são variáveis e as folhas são terminais ou \(\varepsilon\). A leitura das folhas da esquerda para

ocr_outputs/deepseek-ocr-2/page-17.md

@@ -0,0 +1,32 @@
+text[[137, 84, 905, 123]]
+a direita produz a cadeia derivada. Árvores de derivação são a base da análise sintática em compiladores (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+text[[137, 127, 907, 166]]
+A Figura 2.1 mostra a árvore de derivação da cadeia aabb na gramática  \( G_{1} \)  com as produções  \( S \rightarrow aSb \mid ab \) .
+
+image[[396, 185, 649, 278]]
+
+
+figure_title[[189, 292, 853, 309]]
+Figura 2.1: Árvore de derivação de aabb na gramática  \( G_{1} \) :  \( S \Rightarrow aSb \Rightarrow aabb \) .
+
+text[[136, 335, 907, 436]]
+Uma gramática é ambígua se existe pelo menos uma cadeia com mais de uma árvore de derivação distinta. A ambiguidade é indesejável em linguagens de programação, pois pode levar a interpretações diferentes do mesmo programa. Técnicas de desambigução incluem a reformulação da gramática e o uso de regras de precedência (LEWIS; PAPADIMITRIOU, 2004).
+
+sub_title[[137, 464, 480, 484]]
+## 2.3 Hierarquia de Chomsky
+
+text[[136, 501, 907, 562]]
+Chomsky (1956) classificou as gramáticas em quatro tipos conforme as restrições sobre suas produções. A cada tipo corresponde uma classe de linguagens e um dispositivo de reconhecimento (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+figure_title[[364, 576, 680, 594]]
+Tabela 2.1: Hierarquia de Chomsky.
+
+table[[139, 606, 904, 790]]
+<table>TipoGramáticaRestriçõesReconhecedor0Irrestrita\( \alpha \rightarrow \beta \) , sem restrições adicionaisMáquina de Turing1Sensível ao Contexto\( |\alpha| \leq |\beta| \)Aut. Lin. Limitado2Livre de Contexto\( A \rightarrow \alpha \) , com  \( A \in V \)Autômato com Pilha3Regular\( A \rightarrow aB \)  ou  \( A \rightarrow a \)Autômato Finito</table>
+
+text[[137, 816, 907, 876]]
+A relação de inclusão estrita entre as classes é: Regulares ⊂ Livres de Contexto ⊂ Sensíveis ao Contexto ⊂ Recursivamente Enumeráveis. Em cada nível, existem linguagens que não pertencem à classe inferior.
+
+text[[137, 880, 907, 919]]
+A Figura 2.2 ilustra essa relação de inclusão, mostrando exemplos de linguagens pertencentes a cada nível mas não ao nível inferior. Essa organização hierárquica guia o

ocr_outputs/deepseek-ocr-2/page-18.md

@@ -0,0 +1,35 @@
+text[[137, 85, 906, 123]]
+estudo da disciplina: começamos pelas linguagens regulares (mais simples) e avançamos para classes mais expressivas.
+
+image[[305, 139, 738, 375]]
+
+
+figure_title[[137, 386, 905, 420]]
+Figura 2.2: Diagrama de Venn da Hierarquia de Chomsky com exemplos de linguagens em cada nível.
+
+sub_title[[138, 450, 404, 468]]
+## 2.3.1 Exemplos por Tipo
+
+text[[137, 480, 905, 541]]
+Uma gramática regular (Tipo 3) tem produções da forma  \( A \rightarrow aB \)  ou  \( A \rightarrow a \) . Exemplo:  \( G_{4} = (\{S, A\}, \{a, b\}, P, S) \)  com  \( S \rightarrow aS \mid bA \) ,  \( A \rightarrow bA \mid b \)  gera  \( L(G_{4}) = \{a^{m}b^{n} \mid m \geq 0, n \geq 1\} \) . Derivação de aabb:  \( S \Rightarrow aS \Rightarrow aaS \Rightarrow aabA \Rightarrow aabb \) .
+
+text[[137, 544, 907, 627]]
+Uma gramática livre de contexto (Tipo 2) permite  \( A \rightarrow \alpha \)  com  \( \alpha \)  qualquer cadeia de terminais e variáveis:  \( S \rightarrow SS \mid (S) \mid \varepsilon \)  gera a linguagem de parênteses balanceados. Já a linguagem  \( \{a^{n}b^{n}c^{n} \mid n \geq 1\} \)  requer gramática sensível ao contexto (Tipo 1), pois precisa de produções com mais de uma variável no lado esquerdo (SIPSER, 2007).
+
+sub_title[[185, 640, 625, 658]]
+## Exemplo – Derivações Detalhadas por Tipo
+
+text[[153, 668, 792, 688]]
+Tipo 3 (Regular):  \( G_{4} \)  com  \( S \rightarrow aS \mid bA \in A \rightarrow bA \mid b \) . Para gerar abbb:
+
+equation[[383, 707, 664, 725]]
+ \[ S\Rightarrow aS\Rightarrow abA\Rightarrow abbA\Rightarrow abbb \] 
+
+text[[185, 746, 836, 765]]
+Tipo 2 (Livre de Contexto):  \( G_{5} \)  com  \( S \rightarrow SS \mid (S) \mid \varepsilon \) . Para gerar  \( (() \) :
+
+equation[[414, 784, 631, 803]]
+ \[ S\Rightarrow(S)\Rightarrow((S))\Rightarrow(() \] 
+
+text[[153, 824, 889, 907]]
+Tipo 1 (Sensível ao Contexto): A linguagem  \( \{a^{n}b^{n}c^{n} \mid n \geq 1\} \)  não pode ser gerada por nenhuma gramática livre de contexto, mas pode ser gerada por uma gramática sensível ao contexto com regras que garantem  \( |\alpha| \leq |\beta| \)  em cada produção  \( \alpha \rightarrow \beta \) .

ocr_outputs/deepseek-ocr-2/page-19.md

@@ -0,0 +1,29 @@
+sub_title[[137, 85, 741, 102]]
+## 2.3.2 Gramáticas Regulares: Linear à Direita e à Esquerda
+
+text[[136, 116, 906, 218]]
+As gramáticas regulares podem ser classificadas em dois subtipos. Uma gramática linear à direita possui produções da forma  \( A \rightarrow wB \)  ou  \( A \rightarrow w \) , onde  \( w \in T^{*} \)  e  \( B \in V \) . Uma gramática linear à esquerda possui produções da forma  \( A \rightarrow Bw \)  ou  \( A \rightarrow w \) . Ambos os subtipos geram exatamente as linguagens regulares, mas não devem ser misturados na mesma gramática (MENEZES, 2011).
+
+text[[136, 222, 906, 283]]
+A conversão entre gramáticas lineares à direita e à esquerda é possível por meio da reversão da linguagem. Se G é linear à direita e gera L, então existe uma gramática linear à esquerda que gera a mesma linguagem L (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+text[[137, 293, 901, 591]]
+Exemplo – Gramática Linear à Direita e à Esquerda
+Considere a linguagem  \( L = \{a^{m}b^{n} \mid m \geq 1, n \geq 1\} \) .
+Gramática linear à direita:  \( G_{D} = (\{S, A\}, \{a, b\}, P_{D}, S) \)  com:
+ \( S \rightarrow aS \mid aA, \quad A \rightarrow bA \mid b \) 
+Derivação de aabb:  \( S \Rightarrow aS \Rightarrow aaA \Rightarrow aabA \Rightarrow aabb \) .
+Gramática linear à esquerda:  \( G_{E} = (\{S, B\}, \{a, b\}, P_{E}, S) \)  com:
+ \( S \rightarrow Sb \mid Bb, \quad B \rightarrow Ba \mid a \) 
+Derivação de aabb:  \( S \Rightarrow Sb \Rightarrow Bbb \Rightarrow Babb \Rightarrow aabb \) .
+Ambas geram a mesma linguagem L, ilustrando a equivalência entre os dois sub-
+tipos.
+
+sub_title[[137, 618, 700, 638]]
+## 2.4 Operações sobre Linguagens e Fechamento
+
+text[[136, 656, 905, 716]]
+Uma classe de linguagens é fechada sob uma operação se o resultado da operação aplicada a linguagens da classe permanece na classe. As principais operações são: união, interseção, concatenação, complemento e fecho de Kleene (MENEZES, 2011).
+
+text[[137, 719, 905, 758]]
+A Tabela 2.2 resume as propriedades de fechamento. Esses resultados serão demonstrados ao longo dos próximos capítulos para as linguagens regulares.

ocr_outputs/deepseek-ocr-2/page-20.md

@@ -0,0 +1,23 @@
+figure_title[[232, 82, 810, 100]]
+Tabela 2.2: Propriedades de fechamento das classes de linguagens.
+
+table[[140, 113, 904, 297]]
+<table>ClasseUniãoInters.Compl.Concat.KleeneRegularSimSimSimSimSimLivre de ContextoSimNãoNãoSimSimSensível ao Cont.SimSimSimSimSimRec. EnumerávelSimSimNãoSimSim</table>
+
+sub_title[[186, 330, 475, 347]]
+## Fechamento e Decidibilidade
+
+text[[150, 355, 890, 481]]
+As propriedades de fechamento têm consequências práticas importantes. O fato de que linguagens regulares são fechadas sob complemento e interseção permite, por exemplo, verificar se a interseção de duas linguagens regulares é vazia — um problema decidível. Por outro lado, como linguagens livres de contexto não são fechadas sob interseção, problemas análogos para essa classe podem ser indecidíveis (LEWIS; PAPADIMITRIOU, 2004).
+
+sub_title[[137, 514, 720, 534]]
+## 2.5 Relação entre Gramáticas e Reconhecedores
+
+text[[136, 552, 907, 654]]
+Para cada tipo de gramática na Hierarquia de Chomsky, existe um modelo computacional equivalente: gramáticas regulares correspondem a autômatos finitos; gramáticas livres de contexto a autômatos com pilha; gramáticas sensíveis ao contexto a autômatos linearmente limitados; e gramáticas irrestritas a máquinas de Turing (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+text[[136, 658, 907, 739]]
+Essa dualidade entre geradores e reconhecedores permite escolher o formalismo mais conveniente para cada situação: gramáticas são naturais para gerar linguagens, enquanto autômatos são naturais para reconhecer se uma cadeia pertence a uma linguagem (LEWIS; PAPADIMITRIOU, 2004).
+
+text[[137, 743, 907, 783]]
+A Tabela 2.3 resume a correspondência entre formalismos geradores e reconhecedores para cada nível da hierarquia, incluindo os problemas de decisão associados.

ocr_outputs/deepseek-ocr-2/page-21.md

@@ -0,0 +1,47 @@
+figure_title[[146, 82, 897, 100]]
+Tabela 2.3: Correspondência entre gramáticas, reconhecedores e problemas de decisão.
+
+table[[140, 113, 904, 318]]
+<table>TipoGramáticaReconhecedorPertinência3RegularAutômato FinitoDecidível em  \( O(n) \)2Livre de ContextoAut. com PilhaDecidível em  \( O(n^{3}) \)1Sens. ao ContextoAut. Lin. LimitadoDecidível (PSPACE)0IrrestritaMáquina de TuringIndecidível</table>
+
+text[[136, 345, 907, 470]]
+Observe que a complexidade do problema de pertinência cresce com o tipo da gramática. Para linguagens regulares, o teste de pertinência é realizado em tempo linear, simulando o autômato finito. Para linguagens livres de contexto, o algoritmo CYK resolve o problema em tempo  \( O(n^{3}) \) . Para linguagens sensíveis ao contexto, o problema é decidível mas pode exigir espaço exponencial. Para linguagens recursivamente enumeráveis (Tipo 0), o problema de pertinência é decidível em geral (SIPSER, 2007).
+
+sub_title[[137, 497, 425, 515]]
+## 2.6 Lista de Exercícios
+
+text[[157, 534, 810, 551]]
+1. Qual das alternativas descreve corretamente linguagem formal sobre Σ?
+
+text[[195, 567, 666, 584]]
+(a) Conjunto infinito que inclui somente cadeia vazia.
+
+text[[195, 594, 905, 632]]
+(b) Qualquer subconjunto de  \( \Sigma^{*} \)  (finito ou infinito), formado por cadeias de comprimento finito.
+
+text[[196, 643, 557, 659]]
+(c) Todas as cadeias de alfabeto infinito.
+
+text[[195, 670, 708, 687]]
+(d) Apenas cadeias sem repetições, excluindo cadeia vazia.
+
+text[[196, 697, 730, 714]]
+(e) Cadeias com número de símbolos igual ao tamanho de  \( \Sigma \) .
+
+text[[157, 730, 860, 747]]
+2. Em relação a terminais  \( (T) \)  e não-terminais  \( (V) \) , qual afirmação está correta?
+
+text[[196, 763, 552, 780]]
+(a) Terminais substituídos por variáveis.
+
+text[[196, 790, 531, 806]]
+(b) Não-terminais são unidades finais.
+
+text[[196, 818, 544, 835]]
+(c) Terminais não aparecem nas regras.
+
+text[[196, 845, 906, 882]]
+(d) Não-terminais são variáveis que geram cadeias; terminais são elementos básicos das sentenças finais.
+
+text[[197, 893, 481, 910]]
+(e) Não há diferença conceitual.

ocr_outputs/deepseek-ocr-2/page-22.md

@@ -0,0 +1,35 @@
+text[[157, 85, 600, 102]]
+3. A derivação de uma cadeia ocorre por meio de:
+
+text[[193, 117, 907, 157]]
+(a) Substituições sucessivas de subpalavras que correspondem ao lado esquerdo de regras de produção.
+
+text[[194, 166, 475, 184]]
+(b) Comparações entre cadeias.
+
+text[[194, 193, 539, 211]]
+(c) Enumerações de todos os símbolos.
+
+text[[194, 220, 688, 238]]
+(d) Escolha de qualquer sequência sem consultar regras.
+
+text[[195, 247, 617, 265]]
+(e) Retirada de não-terminais sem substituição.
+
+text[[157, 281, 475, 298]]
+4. O conjunto  \( L(G) \)  é formado por:
+
+text[[194, 314, 672, 332]]
+(a) Todas as cadeias de não-terminais deriváveis de S.
+
+text[[194, 341, 673, 359]]
+(b) Qualquer sequência de terminais ou não-terminais.
+
+text[[194, 368, 907, 407]]
+(c) Cadeias sobre T geradas por S por meio de zero ou mais aplicações de regras de produção.
+
+text[[194, 416, 544, 434]]
+(d) Cadeias sobre V e T sem terminais.
+
+text[[195, 443, 596, 461]]
+(e) Cadeias de comprimento infinito sobre V.

ocr_outputs/deepseek-ocr-2/page-23.md

@@ -0,0 +1,36 @@
+sub_title[[137, 87, 904, 142]]
+## 3 LINGUAGENS REGULARES E AUTÔMATOS FI-
+NITOS DETERMINÍSTICOS
+
+text[[136, 171, 907, 294]]
+Neste capítulo, estudamos a classe mais restrita da Hierarquia de Chomsky: as linguagens regulares (Tipo 3). Apesar de serem a classe com menor poder expressivo, possuem enorme importância prática, fundamentando analisadores léxicos, buscas com expressões regulares e validação de formatos de dados. Apresentamos o autômato finito determinístico (AFD) como modelo de reconhecimento dessas linguagens (MENEZES, 2011).
+
+text[[136, 298, 907, 380]]
+Uma linguagem L é regular se existir uma gramática regular, um autômato finito ou uma expressão regular que a defina. Esses três formalismos possuem exatamente o mesmo poder expressivo; neste capítulo, focamos no AFD e em sua relação com gramáticas regulares (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+text[[136, 383, 907, 487]]
+O estudo dos autômatos finitos determinísticos é o ponto de partida natural para a teoria dos autômatos. Por serem o modelo mais simples de computação, os AFDs permitem introduzir conceitos fundamentais — como estado, transição e aceitação — de forma clara e acessível, antes de avançar para modelos mais complexos nos capítulos seguintes.
+
+sub_title[[137, 514, 611, 533]]
+## 3.1 Autômatos Finitos Determinísticos
+
+text[[137, 551, 906, 611]]
+Um AFD é uma 5-tupla  \( M = (\Sigma, Q, \delta, q_0, F) \) , onde:  \( \Sigma \)  é o alfabeto de entrada; Q é o conjunto finito de estados;  \( \delta : Q \times \Sigma \to Q \)  é a função de transição (total);  \( q_0 \in Q \)  é o estado inicial; e  \( F \subseteq Q \)  é o conjunto de estados finais.
+
+text[[137, 616, 907, 697]]
+A função  \( \delta \)  é total: para cada par  \( (q, a) \) , existe exatamente um estado destino. Isso garante o determinismo — a computação nunca “trava”. Quando necessário, adiciona-se um estado morto  \( q_{d} \notin F \)  com  \( \delta(q_{d}, a) = q_{d} \)  para todo a, garantindo totalidade da função (SIPSER, 2007).
+
+sub_title[[186, 710, 330, 727]]
+## Determinismo
+
+text[[152, 737, 888, 777]]
+A propriedade essencial de um AFD é o determinismo: para cada par (estado atual, símbolo lido), existe exatamente um estado seguinte. Isso significa que:
+
+text[[153, 792, 713, 809]]
+• Não há escolha: o próximo estado é unicamente determinado;
+
+text[[153, 825, 696, 842]]
+• Não há bloqueio: a função δ é definida para todo par (q, a);
+
+text[[153, 858, 771, 875]]
+• A computação é uma sequência única de estados (sem ramificações).

ocr_outputs/deepseek-ocr-2/page-24.md

@@ -0,0 +1,29 @@
+sub_title[[137, 85, 641, 102]]
+## 3.1.1 Função de Transição Estendida e Aceitação
+
+text[[136, 116, 905, 175]]
+A função de transição estendida  \( \delta^{*}: Q \times \Sigma^{*} \to Q \)  é definida recursivamente:  \( \delta^{*}(q, \varepsilon) = q \)  e  \( \delta^{*}(q, wa) = \delta(\delta^{*}(q, w), a) \) . A linguagem aceita por  \( M \in L(M) = \{w \in \Sigma^{*} \mid \delta^{*}(q_{0}, w) \in F\} \) .
+
+text[[137, 180, 905, 218]]
+Uma cadeia w é aceita se, ao processar todos os seus símbolos a partir de  \( q_{0} \) , o autômato atinge um estado em F; caso contrário, w é rejeitada.
+
+text[[136, 222, 907, 304]]
+A função estendida  \( \delta^{*} \)  generaliza  \( \delta \)  para cadeias de comprimento arbitrário. Por exemplo, se  \( \delta^{*}(q_{0}, ab) = q_{2} \)  e  \( \delta(q_{2}, a) = q_{1} \) , então  \( \delta^{*}(q_{0}, aba) = q_{1} \) . Essa definição recursiva permite analisar a computação do autômato símbolo por símbolo, o que é a base de qualquer implementação prática (MENEZES, 2011).
+
+sub_title[[137, 332, 530, 351]]
+## 3.2 Representações de um AFD
+
+text[[136, 369, 907, 450]]
+Um AFD pode ser representado pela 5-tupla formal, pela tabela de transição ou pelo diagrama de estados. Na tabela, linhas são estados e colunas são símbolos; → indica o estado inicial e * indica estados finais. No diagrama, estados são círculos, transições são setas rotuladas, o estado inicial recebe seta de entrada, e estados finais têm borda dupla.
+
+text[[136, 455, 907, 535]]
+Cada representação tem suas vantagens: a 5-tupla formal é precisa e adequada para definições e provas; a tabela de transição facilita a implementação computacional; e o diagrama de estados oferece uma visualização intuitiva do comportamento do autômato (SIPSER, 2007).
+
+text[[137, 538, 904, 579]]
+A Tabela 3.1 e a Figura 3.1 mostram o AFD  \( M_{1} = (\{a, b\}, \{q_{0}, q_{a}, q_{b}, q_{f}\}, \delta, q_{0}, \{q_{f}\}) \)  que aceita cadeias contendo aa ou bb como subpalavra.
+
+figure_title[[324, 593, 718, 610]]
+Tabela 3.1: Tabela de transição do AFD  \( M_{1} \) 
+
+table[[451, 625, 593, 744]]
+<table>\( \delta \)ab\( \rightarrow q_{0} \)\( q_{a} \)\( q_{b} \)\( q_{a} \)\( q_{f} \)\( q_{b} \)\( q_{b} \)\( q_{a} \)\( q_{f} \)\( *q_{f} \)\( q_{f} \)\( q_{f} \)</table>

ocr_outputs/deepseek-ocr-2/page-25.md

@@ -0,0 +1,26 @@
+image[[285, 80, 768, 263]]
+
+
+figure_title[[225, 275, 817, 292]]
+Figura 3.1: AFD  \( M_{1} \) : aceita cadeias com aa ou bb como subpalavra.
+
+sub_title[[137, 321, 778, 338]]
+## 3.2.1 Segundo Exemplo: AFD para Cadeias Terminadas em ab
+
+text[[136, 351, 906, 412]]
+Considere o AFD  \( M_{2} = (\{a, b\}, \{q_{0}, q_{1}, q_{2}\}, \delta, q_{0}, \{q_{2}\}) \)  que aceita todas as cadeias sobre  \( \{a, b\} \)  terminadas em ab. A ideia é que o estado  \( q_{0} \)  representa “nenhum progresso”,  \( q_{1} \)  representa “último símbolo lido foi a” e  \( q_{2} \)  representa “últimos dois símbolos foram ab”.
+
+figure_title[[204, 425, 839, 443]]
+Tabela 3.2: Tabela de transição do AFD  \( M_{2} \)  (cadeias terminadas em ab).
+
+table[[451, 456, 593, 555]]
+<table>\( \delta \)ab\( \rightarrow q_{0} \)\( q_{1} \)\( q_{0} \)\( q_{1} \)\( q_{1} \)\( q_{2} \)\( *q_{2} \)\( q_{1} \)\( q_{0} \)</table>
+
+image[[280, 592, 780, 746]]
+
+
+figure_title[[280, 760, 763, 776]]
+Figura 3.2: AFD  \( M_{2} \) : aceita cadeias terminadas em ab.
+
+text[[136, 803, 907, 884]]
+Note que este AFD possui 3 estados, cada um codificando informação sobre os últimos símbolos lidos. Essa técnica de projetar estados como “memória” do sufixo recente é amplamente utilizada na construção de AFDs para padrões de subcadeias (MENEZES, 2011).

ocr_outputs/deepseek-ocr-2/page-26.md

@@ -0,0 +1,56 @@
+sub_title[[137, 86, 523, 106]]
+## 3.3 Computação Passo a Passo 
+
+text[[137, 123, 906, 163]]
+Para verificar a aceitação de uma cadeia, simulamos \(\delta^*\) passo a passo. No AFD \(M_1\), para \(w = abba\): 
+
+equation[[372, 163, 670, 186]]
+\[q_0 \xrightarrow{a} q_a \xrightarrow{b} q_b \xrightarrow{b} q_f \xrightarrow{a} q_f \in F \quad \checkmark\]
+
+text[[137, 196, 644, 216]]
+A cadeia \(abba\) é aceita, pois contém \(bb\). Já para \(w = abab\): 
+
+equation[[372, 231, 666, 255]]
+\[q_0 \xrightarrow{a} q_a \xrightarrow{b} q_b \xrightarrow{a} q_a \xrightarrow{b} q_b \notin F \quad \times\]
+
+text[[137, 275, 612, 294]]
+A cadeia \(abab\) é rejeitada, pois não contém \(aa\) nem \(bb\). 
+
+sub_title[[187, 305, 555, 327]]
+### Exemplo – Computação no AFD \(M_2\) 
+
+text[[157, 334, 825, 355]]
+Verifiquemos a aceitação de cadeias no AFD \(M_2\) (cadeias terminadas em \(ab\)): 
+
+text[[187, 355, 666, 377]]
+Cadeia \(w = bab\): \(q_0 \xrightarrow{b} q_0 \xrightarrow{a} q_1 \xrightarrow{b} q_2 \in F \quad \checkmark\) (aceita) 
+
+text[[187, 376, 692, 398]]
+Cadeia \(w = aba\): \(q_0 \xrightarrow{a} q_1 \xrightarrow{b} q_2 \xrightarrow{a} q_1 \notin F \quad \times\) (rejeitada) 
+
+text[[187, 398, 666, 419]]
+Cadeia \(w = aab\): \(q_0 \xrightarrow{a} q_1 \xrightarrow{a} q_1 \xrightarrow{b} q_2 \in F \quad \checkmark\) (aceita) 
+
+text[[187, 419, 632, 440]]
+Cadeia \(w = bb\): \(q_0 \xrightarrow{b} q_0 \xrightarrow{b} q_0 \notin F \quad \times\) (rejeitada) 
+
+text[[157, 441, 888, 483]]
+Observe que \(bb\) é rejeitada pois não termina em \(ab\), confirmando o comportamento esperado. 
+
+text[[137, 500, 905, 540]]
+Outro exemplo clássico é o AFD para cadeias com número par de \(a\)'s e par de \(b\)'s, que exige \(2 \times 2 = 4\) estados codificando a paridade de cada símbolo (SIPSER, 2007). 
+
+sub_title[[137, 562, 580, 583]]
+### 3.3.1 Exemplo: AFD para Paridade de \(a\)'s 
+
+text[[137, 593, 906, 657]]
+O AFD \(M_3 = (\{a, b\}, \{q_{\text{par}}, q_{\text{impar}}\}, \delta, q_{\text{par}}, \{q_{\text{par}}\})\) aceita cadeias com número par de \(a\)'s (incluindo zero). O estado \(q_{\text{par}}\) indica que o número de \(a\)'s lidos até o momento é par, e \(q_{\text{impar}}\) indica que é ímpar. Os \(b\)'s não alteram a paridade. 
+
+image[[360, 671, 700, 789]]
+ 
+
+image_caption[[258, 800, 784, 820]]
+<center>Figura 3.3: AFD \(M_3\): aceita cadeias com número par de \(a\)'s.</center> 
+
+text[[137, 842, 905, 906]]
+A técnica de codificar informação modular nos estados é extremamente versátil. Por exemplo, para aceitar cadeias cujo comprimento é múltiplo de 3, bastam 3 estados representando os restos 0, 1, 2 da divisão por 3. De modo geral, qualquer propriedade que

ocr_outputs/deepseek-ocr-2/page-27.md

@@ -0,0 +1,39 @@
+text[[137, 84, 905, 123]]
+dependa de uma quantidade finita de informação sobre a cadeia lida pode ser codificada nos estados de um AFD (SIPSER, 2007).
+
+sub_title[[186, 133, 555, 151]]
+## Exemplo – Computação no AFD  \( M_{3} \) 
+
+text[[150, 150, 900, 270]]
+Verifiquemos cadeias no AFD  \( M_{3} \)  (número par de a's):
+Cadeia  \( w = abba: q_{par} \xrightarrow{a} q_{impar} \xrightarrow{b} q_{impar} \xrightarrow{a} q_{impar} \xrightarrow{a} q_{par} \in F \quad \checkmark (2 a's - par) \) 
+Cadeia  \( w = aba: q_{par} \xrightarrow{a} q_{impar} \xrightarrow{b} q_{impar} \xrightarrow{a} q_{par} \in F \quad \checkmark (2 a's - par) \) 
+Cadeia  \( w = a: q_{par} \xrightarrow{a} q_{impar} \notin F \quad \times (1 a - \text{impar}) \) 
+Cadeia  \( w = bbb: q_{par} \xrightarrow{b} q_{par} \xrightarrow{b} q_{par} \xrightarrow{b} q_{par} \in F \quad \checkmark (0 a's - par) \) 
+
+sub_title[[137, 296, 540, 313]]
+## 3.3.2 Estado Morto e Funções Parciais
+
+text[[136, 327, 907, 430]]
+Em alguns livros, a função de transição pode ser definida como parcial:  \( \delta(q,a) \)  pode não estar definida para certos pares  \( (q,a) \) . Nesse caso, a computação “trava” e a cadeia é rejeitada. Para converter um AFD com função parcial em um AFD com função total, basta adicionar um estado morto  \( q_{d} \)  (não-final) e direcionar todas as transições indefinidas para  \( q_{d} \) , com  \( \delta(q_{d},a)=q_{d} \)  para todo  \( a\in\Sigma \)  (MENEZES, 2011).
+
+text[[136, 433, 907, 514]]
+Embora ambas as definições sejam equivalentes em poder expressivo, a função total é preferida em definições formais pois simplifica a análise teórica. Na prática, omitir o estado morto nos diagramas torna as figuras mais legíveis (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+sub_title[[137, 542, 667, 562]]
+## 3.4 Propriedades das Linguagens Regulares
+
+text[[136, 580, 906, 661]]
+A classe das linguagens regulares é fechada sob união, interseção, complemento, concatenação, fecho de Kleene e reversa. O fechamento sob complemento é particularmente simples: dado o AFD M para L, basta inverter estados finais e não-finais para obter um AFD para  \( \overline{L} = \Sigma^{*} - L \)  (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+sub_title[[186, 670, 496, 688]]
+## Fechamento sob Complemento
+
+text[[152, 699, 890, 737]]
+Dado um AFD  \( M = (\Sigma, Q, \delta, q_{0}, F) \)  que reconhece L, o AFD  \( M' = (\Sigma, Q, \delta, q_{0}, Q - F) \)  reconhece  \( \overline{L} = \Sigma^{*} - L \) .
+
+text[[152, 742, 890, 825]]
+Atenção: essa construção exige que  \( \delta \)  seja total. Se o AFD original tiver transições indefinidas, é necessário primeiro adicionar o estado morto antes de inverter os estados finais. Caso contrário, o estado morto (que deveria rejeitar) passaria a aceitar, produzindo um resultado incorreto.
+
+text[[136, 837, 907, 920]]
+Nem toda linguagem é regular. A linguagem  \( \{a^{n}b^{n} \mid n \geq 0\} \)  não é regular, pois um autômato finito não consegue “contar” um número arbitrário de símbolos com sua memória finita (apenas o estado atual). A prova formal utiliza o Lema do Bombeamento (Pumping Lemma), que será estudado em capítulo posterior (MENEZES, 2011).

ocr_outputs/deepseek-ocr-2/page-28.md

@@ -0,0 +1,53 @@
+text[[137, 85, 905, 122]]
+A Tabela 3.3 resume as operações de fechamento com indicações de como a construção é realizada.
+
+figure_title[[243, 136, 801, 154]]
+Tabela 3.3: Operações de fechamento para linguagens regulares.
+
+table[[139, 167, 904, 328]]
+<table>OperaçãoFechada?ConstruçãoUniãoSimProduto de autômatos ou AFN com  \( \varepsilon \) -transiçõesInterseçãoSimProduto de autômatos (estados pares)ComplementoSimInverter estados finais/não-finais no AFDConcatenaçãoSimAFN com  \( \varepsilon \) -transição entre sub-autômatosFecho de KleeneSimAFN com  \( \varepsilon \) -transição de finais ao inicialReversaSimInverter setas, trocar inicial e finais</table>
+
+text[[136, 356, 907, 480]]
+Um resultado importante é que gramáticas regulares e AFDs são formalismos equivalentes: para toda gramática regular pode-se construir um AFD, e vice-versa. A conversão de gramática para AFD associa variáveis a estados e produções a transições (SIPSER, 2007). Na prática, essa construção algorítmica é a base de ferramentas geradoras de analisadores léxicos, que automatizam a implementação de reconhecedores a partir de especificações formais (RAMOS; NETO; VEGA, 2009).
+
+sub_title[[138, 507, 425, 526]]
+## 3.5 Lista de Exercícios
+
+text[[159, 544, 779, 562]]
+1. Qual formalismo NÃO é utilizado para definir linguagens regulares?
+
+text[[196, 577, 384, 595]]
+(a) Autômato Finito
+
+text[[196, 604, 399, 622]]
+(b) Expressão Regular
+
+text[[197, 631, 402, 649]]
+(c) Gramática Regular
+
+text[[196, 659, 490, 676]]
+(d) Gramática Livre de Contexto
+
+text[[197, 686, 389, 703]]
+(e) Movimento Vazio
+
+text[[159, 719, 905, 737]]
+2. Para o autômato  \( M_{1} \)  que reconhece “aa” ou “bb” como subpalavra, qual é  \( \delta^{*}(q_{0}, abba) \) ?
+
+text[[197, 753, 255, 771]]
+(a)  \( q_{0} \) 
+
+text[[197, 779, 252, 797]]
+(b)  \( q_{1} \) 
+
+text[[197, 806, 253, 825]]
+(c)  \( q_{2} \) 
+
+text[[197, 834, 253, 852]]
+(d)  \( q_{f} \) 
+
+text[[197, 861, 323, 878]]
+(e) Indefinida
+
+text[[160, 894, 471, 912]]
+3. Qual linguagem NÃO é regular?

ocr_outputs/deepseek-ocr-2/page-29.md

@@ -0,0 +1,32 @@
+text[[197, 84, 562, 102]]
+(a)  \( \{w \in \{a, b\}^{*} \mid w \text{ contém “aa” ou “bb”}\} \) 
+
+text[[198, 111, 260, 128]]
+(b)  \( \Sigma^{*} \) 
+
+text[[198, 138, 249, 155]]
+(c) ∅
+
+text[[197, 165, 619, 183]]
+(d)  \( \{w \in \{a, b\}^{*} \mid w \text{ com } n^{0} \text{ par de } a \text{ e par de } b\} \) 
+
+text[[198, 192, 357, 210]]
+(e)  \( \{a^{n}b^{n} \mid n \geq 0\} \) 
+
+text[[160, 226, 658, 243]]
+4. No quintuplo  \( M = (\Sigma, Q, \delta, q_{0}, F) \) , o que representa  \( \delta \) ?
+
+text[[197, 259, 432, 276]]
+(a) Conjunto de estados Q
+
+text[[197, 286, 377, 303]]
+(b) Estado inicial  \( q_{0} \) 
+
+text[[198, 313, 376, 330]]
+(c) Estados finais F
+
+text[[197, 341, 409, 357]]
+(d) Função de transição
+
+text[[198, 368, 332, 384]]
+(e) Alfabeto  \( \Sigma \)

ocr_outputs/deepseek-ocr-2/page-30.md

@@ -0,0 +1,23 @@
+sub_title[[137, 87, 919, 110]]
+## 4 AUTÔMATOS FINITOS NÃO-DETERMINÍSTICOS
+
+text[[136, 139, 907, 283]]
+Neste capítulo, estudamos os autômatos finitos não-determinísticos (AFN), uma extensão dos AFDs que permite maior flexibilidade na modelagem de linguagens. Em um AFN, cada par (estado, símbolo) pode levar a múltiplos estados simultaneamente. Apesar dessa aparente extensão, AFNs e AFDs reconhecem exatamente a mesma classe de linguagens — as linguagens regulares. Apresentamos também o algoritmo de construção de subconjuntos, que converte qualquer AFN em um AFD equivalente (MENEZES, 2011).
+
+text[[136, 287, 906, 368]]
+O não-determinismo é um conceito central na Teoria da Computação. Intuitivamente, o autômato explora simultaneamente todos os caminhos de computação possíveis, e aceita a cadeia se pelo menos um desses caminhos atinge um estado final (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+text[[136, 373, 907, 497]]
+Do ponto de vista prático, o não-determinismo oferece uma poderosa ferramenta de projeto: ao invés de construir diretamente um AFD — que pode exigir raciocínio complexo sobre como codificar informação nos estados — pode-se projetar primeiro um AFN mais simples e intuitivo, e depois converter sistematicamente para um AFD equivalente. Essa abordagem é amplamente empregada na construção de analisadores léxicos a partir de expressões regulares (RAMOS; NETO; VEGA, 2009).
+
+sub_title[[137, 524, 503, 543]]
+## 4.1 Definição Formal de AFN
+
+text[[136, 562, 906, 644]]
+Um AFN é uma 5-tupla  \( M = (\Sigma, Q, \delta, q_0, F) \) , com a diferença fundamental em relação ao AFD na função de transição:  \( \delta : Q \times \Sigma \to 2^{Q} \) . A notação  \( 2^{Q} \)  representa o conjunto das partes de Q; assim,  \( \delta(q, a) \)  retorna um conjunto de estados (possivelmente vazio). Quando  \( \delta(q, a) = \emptyset \) , a computação naquele ramo “morre” (SIPSER, 2007).
+
+text[[136, 647, 905, 707]]
+Todo AFD é um caso particular de AFN em que  \( |\delta(q,a)|=1 \)  para todo par  \( (q,a) \) . Portanto, a classe de linguagens reconhecidas por AFNs é pelo menos tão ampla quanto a dos AFDs — e, como veremos, é exatamente a mesma.
+
+sub_title[[186, 720, 475, 738]]
+## AFD vs AFN – Comparação

ocr_outputs/deepseek-ocr-2/page-31.md

@@ -0,0 +1,32 @@
+table[[150, 88, 899, 288]]
+<table>CaracterísticaAFDAFNFunção δ\( Q \times \Sigma \rightarrow Q \)\( Q \times \Sigma \rightarrow 2^{Q} \)Transições por (q, a)Exatamente 1Zero ou maisDeterminismoSimNãoAceitaçãoEstado final atingidoAlgum caminho atingeFPoder expressivoLing. regularesLing. regulares</table>
+
+sub_title[[137, 312, 688, 330]]
+## 4.1.1 Exemplo: AFN para Cadeias Terminadas em ab
+
+text[[163, 343, 866, 361]]
+O AFN  \( M_{1}=\left(\{a,b\},\{q_{0},q_{1},q_{2}\},\delta,q_{0},\{q_{2}\}\right) \)  reconhece cadeias terminadas em ab:
+
+figure_title[[324, 375, 718, 392]]
+Tabela 4.1: Tabela de transição do AFN  \( M_{1} \) .
+
+table[[418, 406, 627, 506]]
+<table>\( \delta \)ab\( \rightarrow q_{0} \)\( \{q_{0}, q_{1}\} \)\( \{q_{0}\} \)\( q_{1} \)\( \emptyset \)\( \{q_{2}\} \)\( *q_{2} \)\( \emptyset \)\( \emptyset \)</table>
+
+image[[303, 542, 754, 630]]
+
+
+figure_title[[264, 638, 778, 655]]
+Figura 4.1: AFN  \( M_{1} \) : reconhece cadeias terminadas em ab.
+
+text[[137, 682, 904, 719]]
+No estado  \( q_{0} \) , ao ler a, o autômato pode tanto permanecer em  \( q_{0} \)  quanto ir para  \( q_{1} \) . Essa é a essência do não-determinismo.
+
+text[[135, 724, 907, 827]]
+Compare este AFN com o AFD equivalente da Figura 3.2 do capítulo anterior: ambos reconhecem a mesma linguagem (cadeias terminadas em ab), mas o AFN é mais simples de projetar. No AFN, a “adivinhação” de quando iniciar o reconhecimento do padrão ab é realizada pelo não-determinismo; no AFD, essa informação precisa ser codificada explicitamente nos estados (MENEZES, 2011).
+
+sub_title[[137, 849, 817, 867]]
+## 4.1.2 Exemplo: AFN para Cadeias Contendo aba como Subpalavra
+
+text[[137, 880, 905, 918]]
+Considere o AFN  \( M_{3} = (\{a, b\}, \{q_{0}, q_{1}, q_{2}, q_{3}\}, \delta, q_{0}, \{q_{3}\}) \)  que reconhece cadeias contendo aba como subpalavra:

ocr_outputs/deepseek-ocr-2/page-32.md

@@ -0,0 +1,50 @@
+image[[216, 85, 844, 172]]
+ 
+
+image_caption[[208, 181, 833, 202]]
+<center>Figura 4.2: AFN \(M_3\): reconhece cadeias contendo aba como subpalavra.</center> 
+
+text[[137, 223, 905, 330]]
+O padrão é claro: o autômato permanece em \(q_0\) lendo qualquer símbolo, até “adivinhar” que a ocorrência de aba está começando. A partir daí, segue a sequência \(q_0 \xrightarrow{a} q_1 \xrightarrow{b} q_2 \xrightarrow{a} q_3\), e permanece em \(q_3\) (estado final) lendo o restante da cadeia. Esse padrão de projeto — um “laço de espera” seguido de uma sequência linear — é utilizado para reconhecer qualquer subcadeia fixa (SIPSER, 2007). 
+
+sub_title[[137, 355, 710, 379]]
+## 4.2 Função de Transição Estendida e Aceitação 
+
+text[[137, 392, 907, 437]]
+A **função de transição estendida** \(\delta^* : 2Q \times \Sigma^* \to 2Q\) opera sobre conjuntos de estados: \(\delta^*(P, \varepsilon) = P\) e \(\delta^*(P, wa) = \bigcup_{q \in \delta^*(P, wa)} \delta(q, a)\). 
+
+text[[137, 435, 905, 499]]
+Uma cadeia \(w\) é **aceita** por \(M\) se \(\delta^*( \{q_0\}, w) \cap F \neq \emptyset\), ou seja, se ao menos um caminho de computação atinge um estado final. A aceitação em AFNs é **existencial**: basta um caminho bem-sucedido (MENEZES, 2011). 
+
+text[[137, 500, 904, 607]]
+A natureza existencial da aceitação tem uma interpretação computacional interessante: podemos imaginar que o AFN “clona” a si mesmo a cada ponto de escolha, explorando todos os caminhos em paralelo. Se qualquer clone atinge um estado final ao fim da leitura, a cadeia é aceita. Essa metáfora do paralelismo ilimitado é o que torna os AFNs mais fáceis de projetar, embora não amplie o poder expressivo (SIPSER, 2007). 
+
+sub_title[[137, 627, 464, 648]]
+### 4.2.1 Exemplo de Computação 
+
+text[[167, 657, 448, 679]]
+Para \(\delta^*( \{q_0\}, aab)\) no AFN \(M_1\): 
+
+equation[[277, 696, 770, 768]]
+\[ 
+\begin{align*}
+\delta^*( \{q_0\}, a) &= \delta(q_0, a) = \{q_0, q_1\} \\
+\delta^*( \{q_0\}, aa) &= \delta(q_0, a) \cup \delta(q_1, a) = \{q_0, q_1\} \cup \emptyset = \{q_0, q_1\} \\
+\delta^*( \{q_0\}, aab) &= \delta(q_0, b) \cup \delta(q_1, b) = \{q_0\} \cup \{q_2\} = \{q_0, q_2\}
+\end{align*}
+\]
+
+text[[137, 785, 456, 805]]
+Como \(q_2 \in F\), a cadeia \(aab\) é aceita. 
+
+sub_title[[187, 817, 655, 837]]
+#### Exemplo – Computação Detalhada: Cadeia bab 
+
+text[[157, 845, 612, 867]]
+Analisemos \(\delta^*( \{q_0\}, bab)\) passo a passo no AFN \(M_1\): 
+
+text[[187, 867, 644, 888]]
+**Passo 1** — leitura de \(b\): \(\delta^*( \{q_0\}, b) = \delta(q_0, b) = \{q_0\}\) 
+
+text[[187, 888, 683, 910]]
+**Passo 2** — leitura de \(a\): \(\delta^*( \{q_0\}, ba) = \delta(q_0, a) = \{q_0, q_1\}\)

ocr_outputs/deepseek-ocr-2/page-33.md

@@ -0,0 +1,48 @@
+text[[185, 80, 884, 122]]
+Passo 3 — leitura de b: \(\delta^{*}(\{q_0\}, bab) = \delta(q_0, b) \cup \delta(q_1, b) = \{q_0\} \cup \{q_2\} = \{q_0, q_2\}\)
+Como \(\{q_0, q_2\} \cap \{q_2\} = \{q_2\} \neq \emptyset\), a cadeia bab é aceita. 
+
+sub_title[[185, 142, 650, 163]]
+Exemplo – Computação Detalhada: Cadeia ba 
+
+text[[157, 170, 810, 258]]
+Analisemos \(\delta^{*}(\{q_0\}, ba)\) no AFN \(M_1\):
+
+Passo 1 — leitura de b: \(\delta^{*}(\{q_0\}, b) = \delta(q_0, b) = \{q_0\}\)
+
+Passo 2 — leitura de a: \(\delta^{*}(\{q_0\}, ba) = \delta(q_0, a) = \{q_0, q_1\}\)
+
+Como \(\{q_0, q_1\} \cap \{q_2\} = \emptyset\), a cadeia ba é rejeitada (não termina em ab). 
+
+sub_title[[137, 287, 835, 311]]
+4.3 Equivalência AFN–AFD: Construção de Subconjuntos 
+
+text[[137, 325, 912, 410]]
+O resultado central deste capítulo é que para todo AFN existe um AFD equivalente. A demonstração é construtiva e chama-se **construção de subconjuntos**: cada estado do AFD corresponde a um subconjunto de estados do AFN. Dado \(M_N = (\Sigma, Q_N, \delta_N, q_0, F_N)\), constrói-se \(M_D = (\Sigma, Q_D, \delta_D, \{q_0\}, F_D)\) onde (HOPCROFT; ULLMAN; MOTWANI, 2002): 
+
+text[[137, 416, 666, 440]]
+- \(\delta_D(S, a) = \bigcup_{q \in S} \delta_N(q, a)\) para cada macro-estado \(S \subseteq Q_N\); 
+
+text[[137, 447, 424, 469]]
+- \(F_D = \{S \in Q_D \mid S \cap F_N \neq \emptyset\}\). 
+
+text[[137, 476, 907, 519]]
+Se o AFN possui \(n\) estados, o AFD pode ter até \(2^n\) estados. Na prática, muitos subconjuntos são inacessíveis e o AFD resultante é menor. 
+
+text[[137, 519, 907, 626]]
+A construção é realizada incrementalmente: começa-se pelo macro-estado \(\{q_0\}\) e, para cada macro-estado alcançado, computam-se as transições com cada símbolo do alfabeto. Macro-estados novos são adicionados à fila de processamento até que nenhum novo estado seja gerado. Esse processo sempre termina, pois o número de subconjuntos possíveis é finito (\(2^n\)) (MENEZES, 2011). 
+
+sub_title[[137, 645, 441, 665]]
+4.3.1 Exemplo de Conversão 
+
+text[[166, 675, 558, 697]]
+Aplicando ao AFN \(M_1\) (\(q_0, q_1, q_2\); \(F = \{q_2\}\)): 
+
+table_caption[[303, 705, 738, 726]]
+Tabela 4.2: Construção de subconjuntos para \(M_1\). 
+
+table[[401, 739, 640, 840]]
+<table>Macro-estadoab→ A = {q<sub>0</sub>}BAB = {q<sub>0</sub>, q<sub>1</sub>}BC*C = {q<sub>0</sub>, q<sub>2</sub>}BA</table>
+
+text[[137, 857, 907, 922]]
+O AFD equivalente tem 3 macro-estados acessíveis (\(A, B, C\)), com \(F_D = \{C\}\) pois \(C\) contém \(q_2\). Podemos verificar: \(ab\) leva \(A \to B \to C \in F_D\) (aceita); \(ba\) leva \(A \to A \to B \notin F_D\) (rejeitada) (SIPSER, 2007).

ocr_outputs/deepseek-ocr-2/page-34.md

@@ -0,0 +1,53 @@
+sub_title[[186, 86, 735, 105]]
+Exemplo – Construção de Subconjuntos Passo a Passo 
+
+text[[156, 113, 568, 134]]
+Vamos detalhar a construção para o AFN \(M_1\): 
+
+text[[186, 135, 580, 155]]
+**Início:** O estado inicial do AFD é \(A = \{q_0\}\). 
+
+text[[186, 156, 410, 177]]
+**Processando** \(A = \{q_0\}\): 
+
+text[[156, 189, 666, 210]]
+- \(\delta_D(A, a) = \delta_N(q_0, a) = \{q_0, q_1\} = B\) (novo macro-estado) 
+
+text[[156, 222, 460, 243]]
+- \(\delta_D(A, b) = \delta_N(q_0, b) = \{q_0\} = A\) 
+
+text[[186, 255, 437, 277]]
+**Processando** \(B = \{q_0, q_1\}\): 
+
+text[[156, 288, 707, 310]]
+- \(\delta_D(B, a) = \delta_N(q_0, a) \cup \delta_N(q_1, a) = \{q_0, q_1\} \cup \emptyset = \{q_0, q_1\} = B\) 
+
+text[[156, 321, 759, 344]]
+- \(\delta_D(B, b) = \delta_N(q_0, b) \cup \delta_N(q_1, b) = \{q_0\} \cup \{q_2\} = \{q_0, q_2\} = C\) (novo) 
+
+text[[186, 355, 434, 376]]
+**Processando** \(C = \{q_0, q_2\}\): 
+
+text[[156, 388, 617, 410]]
+- \(\delta_D(C, a) = \delta_N(q_0, a) \cup \delta_N(q_2, a) = \{q_0, q_1\} \cup \emptyset = B\) 
+
+text[[156, 421, 583, 443]]
+- \(\delta_D(C, b) = \delta_N(q_0, b) \cup \delta_N(q_2, b) = \{q_0\} \cup \emptyset = A\) 
+
+text[[156, 455, 888, 498]]
+**Fim:** Nenhum novo macro-estado gerado. Estados finais: \(C\) contém \(q_2 \in F_N\), logo \(F_D = \{C\}\). 
+
+sub_title[[137, 529, 592, 551]]
+4.4 Vantagens do Não-Determinismo 
+
+text[[137, 567, 907, 652]]
+Embora AFNs não reconheçam linguagens adicionais, oferecem vantagens de **concisão** (podem ter exponencialmente menos estados que o menor AFD equivalente), **facilidade de projeto** (projetar primeiro um AFN e depois converter) e **composição** (operações de fechamento são demonstradas mais facilmente com AFNs). 
+
+text[[137, 654, 907, 758]]
+Existe uma família de linguagens em que o menor AFN requer \(n+1\) estados e o menor AFD requer \(2^n\) estados, mostrando que o limite exponencial é justo (HOPCROFT; ULLMAN; MOTWANI, 2002). Aspectos práticos da implementação eficiente da construção de subconjuntos são discutidos em detalhe na literatura voltada à modelagem e construção de autômatos (RAMOS; NETO; VEGA, 2009). 
+
+sub_title[[186, 771, 526, 792]]
+Explosão Exponencial de Estados 
+
+text[[156, 800, 888, 906]]
+Um exemplo clássico da explosão exponencial é a linguagem \(L_n = \{w \in \{a, b\}^* \mid o n\)-ésimo símbolo antes do fim é \(a\}\). Um AFN para \(L_n\) precisa de apenas \(n+1\) estados (adivinha quando faltam \(n\) símbolos e verifica que o próximo é \(a\)), mas qualquer AFD equivalente requer pelo menos \(2^n\) estados, pois precisa “lembrar” os últimos \(n\) símbolos lidos.

ocr_outputs/deepseek-ocr-2/page-35.md

@@ -0,0 +1,47 @@
+text[[152, 81, 890, 145]]
+Esse resultado demonstra que, embora AFNs e AFDs tenham o mesmo poder expressivo, a representação por AFN pode ser exponencialmente mais compacta (SIP-SER, 2007). 
+
+text[[137, 156, 905, 261]]
+Na prática, muitas aplicações utilizam uma abordagem híbrida: o projetista especifica o comportamento desejado por meio de expressões regulares ou AFNs, e uma ferramenta automatizada realiza a conversão para AFD quando necessário para eficiência de execução. Ferramentas como lex e flex empregam exatamente essa estratégia na geração de analisadores léxicos (LEWIS; PAPADIMITRIOU, 2004). 
+
+text[[137, 262, 904, 305]]
+A Tabela 4.3 sintetiza as principais diferenças entre AFDs e AFNs, incluindo aspectos de complexidade de tempo e espaço que são relevantes para aplicações práticas. 
+
+table_caption[[290, 315, 752, 336]]
+Tabela 4.3: Resumo comparativo entre AFD e AFN. 
+
+table[[137, 345, 907, 579]]
+<table>AspectoAFDAFNNúmero de estadosPode ser exponencialmente maiorGeralmente mais compactoTempo de simulação\(O(n)\) por cadeia de tamanho \(n\)\(O(n \cdot |Q|)\) por cadeiaFacilidade de projetoRequer raciocínio detalhadoMais intuitivo e modularConversão—Construção de subconjuntosUso em compiladoresExecução do analisadorEspecificação de padrões</table>
+
+sub_title[[137, 607, 428, 629]]
+## 4.5 Lista de Exercícios 
+
+text[[161, 645, 714, 666]]
+1. Qual enunciado descreve a função de transição de um AFN? 
+
+text[[197, 677, 369, 698]]
+(a) \(\delta: Q \times \Sigma \to Q\) 
+
+text[[197, 703, 397, 725]]
+(b) \(\delta: Q \times \Sigma \to \mathcal{P}(Q)\) 
+
+text[[197, 728, 375, 752]]
+(c) \(\delta: Q \times \Sigma \to 2^Q\) 
+
+text[[197, 757, 375, 778]]
+(d) \(\delta: 2^Q \times \Sigma \to Q\) 
+
+text[[197, 783, 373, 805]]
+(e) \(\delta: \Sigma \times Q \to 2^Q\) 
+
+text[[161, 817, 600, 839]]
+2. A função estendida \(\delta^*\) satisfaz \(\delta^*(P, aw) = \dots\)? 
+
+text[[197, 849, 383, 871]]
+(a) \(\delta(P, a) \cup \delta(P, w)\) 
+
+text[[197, 875, 350, 897]]
+(b) \(\delta^*(\delta(P, a), \varepsilon)\) 
+
+text[[197, 902, 388, 925]]
+(c) \(\bigcup_{q \in P} \delta^*(q, a) \cup w\)

ocr_outputs/deepseek-ocr-2/page-36.md

@@ -0,0 +1,41 @@
+text[[196, 80, 410, 108]]
+(d) \(\delta^{*}\left(\bigcup_{q\in P}\delta(q,a), w\right)\) 
+
+text[[197, 110, 430, 133]]
+(e) \(\{\delta(q,a) \mid q \in \delta^{*}(P,w)\}\) 
+
+text[[161, 145, 675, 166]]
+3. Qual condição garante que \(w\) é aceita por um AFN \(M\)? 
+
+text[[196, 178, 546, 199]]
+(a) \(\delta(q_0, w)\) definido para todo símbolo. 
+
+text[[196, 206, 450, 226]]
+(b) Todo caminho atinge \(F\). 
+
+text[[196, 234, 721, 254]]
+(c) Existe pelo menos um caminho que atinge estado em \(F\). 
+
+text[[196, 260, 480, 280]]
+(d) Conjunto alcançado é vazio. 
+
+text[[196, 287, 460, 309]]
+(e) \(\delta^{*}(\{q_0\}, w) \cap (Q \setminus F) \neq \emptyset\) 
+
+text[[161, 321, 787, 342]]
+4. Se um AFN tem \(n\) estados, máximo de estados no AFD equivalente? 
+
+text[[196, 353, 264, 375]]
+(a) \(n^2\) 
+
+text[[196, 383, 287, 402]]
+(b) \(n + 1\) 
+
+text[[196, 408, 264, 429]]
+(c) \(2n\) 
+
+text[[196, 435, 262, 456]]
+(d) \(2^n\) 
+
+text[[196, 463, 260, 483]]
+(e) \(n!\)

ocr_outputs/deepseek-ocr-2/page-37.md

@@ -0,0 +1,26 @@
+sub_title[[139, 87, 905, 142]]
+## 5 AUTÔMATOS FINITOS COM MOVIMENTOS VA-ZIOS
+
+text[[137, 171, 907, 274]]
+Neste capítulo, estendemos o modelo de autômatos finitos ao permitir transições vazias (ε-transições), obtendo os autômatos finitos com movimentos vazios (AFN-ε). Em uma ε-transição, o autômato muda de estado sem consumir nenhum símbolo da entrada. Apesar dessa extensão, os AFN-ε reconhecem exatamente a mesma classe de linguagens que AFDs e AFNs: as linguagens regulares (MENEZES, 2011).
+
+text[[137, 277, 907, 358]]
+As  \( \varepsilon \) -transições são úteis na construção modular de autômatos a partir de expressões regulares (construção de Thompson) e na demonstração de propriedades de fechamento das linguagens regulares. Elas permitem “conectar” sub-autômatos sem redesenhar sua estrutura interna (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+text[[137, 363, 907, 487]]
+Do ponto de vista conceitual, as  \( \varepsilon \) -transições representam mudanças de estado “espontâneas” — o autômato pode transitar entre estados sem necessidade de estímulo externo. Essa liberdade adicional simplifica significativamente a construção composicional de autômatos, conforme veremos ao longo deste capítulo. É importante ressaltar que essa extensão não amplia o poder computacional do modelo; trata-se exclusivamente de uma conveniência de projeto (SIPSER, 2007).
+
+sub_title[[138, 514, 524, 533]]
+## 5.1 Definição Formal de AFN-ε
+
+text[[137, 551, 907, 633]]
+Um AFN-ε é uma 5-tupla  \( M = (\Sigma, Q, \delta, q_{0}, F) \) , onde a função de transição tem domínio estendido:  \( \delta : Q \times (\Sigma \cup \{\varepsilon\}) \to 2^{Q} \) . Assim,  \( \delta(q, \varepsilon) \)  indica os estados alcançáveis a partir de q sem consumir símbolo algum da entrada. Graficamente, as  \( \varepsilon \) -transições são setas rotuladas com  \( \varepsilon \)  (SIPSER, 2007).
+
+text[[137, 637, 907, 697]]
+A diferença em relação ao AFN convencional é justamente essa possibilidade de transição espontânea: o autômato pode “avançar” entre estados gratuitamente, sem que o cabeçote de leitura se mova.
+
+sub_title[[188, 710, 481, 728]]
+## Comparação: AFN vs AFN-ε
+
+table[[193, 740, 860, 890]]
+<table>CaracterísticaAFNAFN-εDomínio de δQ × ΣQ × (Σ ∪ {ε})Transições vaziasNão permitidasPermitidasPoder expressivoLing. regularesLing. regularesUso principalReconhecimentoConstrução composicional</table>

ocr_outputs/deepseek-ocr-2/page-38.md

@@ -0,0 +1,53 @@
+sub_title[[138, 87, 293, 105]]
+## 5.2 Fecho-ε
+
+text[[137, 125, 906, 183]]
+O conceito central para trabalhar com AFN-ε é o fecho-ε (ou ε-closure). Ele captura todos os estados alcançáveis a partir de um estado usando apenas ε-transições. A definição recursiva é:
+
+equation[[354, 181, 685, 232]]
+ \[ \delta_{\varepsilon}(q)=\{q\}\cup\delta(q,\varepsilon)\cup\left(\bigcup_{p\in\delta(q,\varepsilon)}\delta_{\varepsilon}(p)\right) \] 
+
+text[[137, 240, 905, 279]]
+Para um conjunto \(P \subseteq Q\): \(\delta_{\varepsilon}(P) = \bigcup_{q \in P} \delta_{\varepsilon}(q)\). Na prática, computa-se por busca em largura ou profundidade no grafo das \(\varepsilon\)-transições (MENEZES, 2011).
+
+text[[138, 283, 905, 323]]
+O fecho-ε sempre inclui o próprio estado (zero ε-transições é válido). Assim, δε(q) ⊇ {q} para todo q.
+
+sub_title[[186, 336, 551, 354]]
+## Algoritmo para Computar o Fecho-ε
+
+text[[154, 365, 775, 383]]
+O fecho-ε de um estado q pode ser computado pelo seguinte algoritmo:
+
+text[[180, 397, 712, 416]]
+1. Inicialize o conjunto resultado  \( R = \{q\} \)  e uma fila  \( F = [q] \) .
+
+text[[179, 431, 473, 448]]
+2. Enquanto F não estiver vazia:
+
+text[[213, 464, 472, 481]]
+(a) Retire um estado p de F.
+
+text[[212, 490, 715, 509]]
+(b) Para cada  \( r \in \delta(p, \varepsilon) \) : se  \( r \notin R \) , adicione r a R e a F.
+
+text[[179, 524, 306, 541]]
+3. Retorne R.
+
+text[[153, 557, 888, 598]]
+Esse algoritmo é essencialmente uma busca em largura (BFS) no grafo dirigido formado pelas ε-transições. Sua complexidade é  \( O(|Q|^{2}) \)  no pior caso.
+
+sub_title[[138, 627, 416, 644]]
+## 5.2.1 Exemplo: AFN-ε M7
+
+text[[138, 657, 905, 697]]
+Considere  \( M_{7}=\left(\{a\},\{q_{0},q_{f}\},\delta,q_{0},\{q_{f}\}\right) \)  com  \( \delta(q_{0},\varepsilon)=\{q_{f}\} \)  e  \( \delta(q_{f},a)=\{q_{f}\} \) . Este autômato reconhece  \( L(M_{7})=\{a\}^{*}=\{\varepsilon,a,aa,\ldots\} \) .
+
+image[[380, 715, 677, 795]]
+
+
+figure_title[[346, 806, 696, 824]]
+Figura 5.1: AFN-ε M7: reconhece {a}*.
+
+text[[139, 848, 905, 889]]
+O fecho-ε: \(\delta_{\varepsilon}(q_{0})=\{q_{0},q_{f}\}\) (pois \(q_{f}\in\delta(q_{0},\varepsilon)\)) e \(\delta_{\varepsilon}(q_{f})=\{q_{f}\}\). Como \(\delta_{\varepsilon}(q_{0})\cap F=\{q_{f}\}\neq\emptyset\), a cadeia \(\varepsilon\) é aceita.

ocr_outputs/deepseek-ocr-2/page-39.md

@@ -0,0 +1,41 @@
+sub_title[[137, 85, 510, 102]]
+## 5.2.2 Exemplo: AFN-ε para  \( a^{*}b^{*}\cup c \) 
+
+text[[136, 116, 907, 177]]
+Considere o AFN-ε  \( M_{8} = (\{a, b, c\}, \{q_{0}, q_{1}, q_{2}, q_{3}, q_{4}\}, \delta, q_{0}, \{q_{2}, q_{4}\}) \)  que reconhece a linguagem  \( a^{*}b^{*} \cup \{c\} \) . A ideia é construir dois sub-autômatos — um para  \( a^{*}b^{*} \)  e outro para  \( \{c\} \)  — e conectá-los por ε-transições a partir do estado inicial.
+
+image[[315, 196, 744, 391]]
+
+
+figure_title[[202, 402, 840, 419]]
+Figura 5.2: AFN-ε  \( M_{8} \) : reconhece  \( a^{*}b^{*}\cup\{c\} \)  usando construção modular.
+
+text[[136, 443, 907, 526]]
+Neste exemplo,  \( \delta_{\varepsilon}(q_{0})=\{q_{0},q_{1},q_{2}\} \)  pois  \( q_{0}\stackrel{\varepsilon}{\rightarrow}q_{1}\stackrel{\varepsilon}{\rightarrow}q_{2} \) . Como  \( q_{2}\in F \) , a cadeia  \( \varepsilon \)  é aceita (pertence a  \( a^{*}b^{*} \) ). A modularidade da construção é evidente: os sub-autômatos para  \( a^{*}b^{*} \)  e para  \( \{c\} \)  são independentes, conectados apenas pelas  \( \varepsilon \) -transições de  \( q_{0} \)  (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+sub_title[[137, 554, 566, 573]]
+## 5.3 Função de Transição Estendida
+
+text[[166, 591, 741, 608]]
+A função estendida  \( \delta^{*}:2^{Q}\times\Sigma^{*}\to2^{Q} \)  para AFN- \( \varepsilon \)  é definida por:
+
+text[[161, 624, 392, 641]]
+1. Base:  \( \delta^{*}(P,\varepsilon)=\delta_{\varepsilon}(P) \) 
+
+text[[161, 657, 666, 674]]
+2. Passo:  \( \delta^{*}(P,wa)=\delta_{\varepsilon}(\{r\mid\exists s\in\delta^{*}(P,w):r\in\delta(s,a)\}) \) 
+
+text[[136, 691, 905, 729]]
+Ou seja: compute os estados atuais após ler w; aplique a transição com o símbolo a; aplique o fecho-ε ao resultado (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+text[[137, 733, 905, 771]]
+A cadeia w é aceita se  \( \delta^{*}(\{q_{0}\},w)\cap F\neq\emptyset \) , exatamente como nos AFNs convencionais, mas com o fecho-ε incorporado em cada passo.
+
+text[[188, 786, 650, 803]]
+Exemplo – Computação em  \( M_{7} \)  com Cadeia aa
+
+text[[157, 815, 499, 832]]
+Calculemos  \( \delta^{*}(\{q_{0}\},aa) \)  no AFN- \( \varepsilon \)   \( M_{7} \) :
+
+text[[186, 836, 523, 854]]
+Base:  \( \delta^{*}(\{q_{0}\},\varepsilon)=\delta_{\varepsilon}(\{q_{0}\})=\{q_{0},q_{f}\} \)

ocr_outputs/deepseek-ocr-2/page-40.md

@@ -0,0 +1,64 @@
+text[[186, 81, 410, 100]]
+Passo 1 — leitura de a: 
+
+equation[[275, 117, 770, 138]]
+\[
+\text{Transições com } a : \quad \delta(q_0, a) \cup \delta(q_f, a) = \emptyset \cup \{q_f\} = \{q_f\}
+\]
+
+equation[[358, 142, 600, 165]]
+\[
+\text{Fecho-}\varepsilon : \quad \delta_{\varepsilon}(\{q_f\}) = \{q_f\}
+\]
+
+text[[155, 181, 412, 202]]
+Portanto, \(\delta^*(q_0), a) = \{q_f\}\). 
+
+text[[186, 204, 410, 223]]
+Passo 2 — leitura de a: 
+
+equation[[360, 241, 677, 263]]
+\[
+\text{Transições com } a : \quad \delta(q_f, a) = \{q_f\}
+\]
+
+equation[[0, 0, 999, 799]]
+\[
+\text{Fecho-}\varepsilon : \quad \delta_{\varepsilon}(\{q_f\}) = \{q_f\}
+\]
+Portanto, \(\delta^*(q_0), aa) = \{q_f\}\).
+
+Como \(q_f \in F\), a cadeia \(aa\) é aceita.
+
+text[[155, 351, 522, 405]]
+5.4 Eliminação de ε-Transições 
+
+text[[137, 419, 904, 460]]
+Todo AFN-ε M = (Σ, Q, δ, q₀, F) pode ser convertido em um AFN equivalente M' = (Σ, Q, δ', q₀, F') sem ε-transições. A construção define (MENEZES, 2011): 
+
+equation[[395, 473, 644, 529]]
+\[
+\delta'(p, a) = \delta_{\varepsilon} \left( \bigcup_{q \in \delta_{\varepsilon}(p)} \delta(q, a) \right)
+\]
+
+text[[137, 535, 905, 597]]
+Ou seja: primeiro aplica-se o fecho-ε ao estado p; depois, para cada estado no fecho, aplica-se a transição com a; finalmente, aplica-se novamente o fecho-ε ao resultado. Os novos estados finais são: 
+
+equation[[374, 615, 666, 636]]
+\[
+F' = F \cup \{q \in Q \mid \delta_{\varepsilon}(q) \cap F \neq \emptyset\}
+\]
+
+text[[137, 655, 904, 718]]
+Um estado torna-se final se ele próprio já era final ou se alcança um estado final por
+ε-transições. Em particular, se \(\delta_{\varepsilon}(q_0) \cap F \neq \emptyset\), o estado inicial deve ser marcado como
+final para garantir que \(\varepsilon \in L(M')\). 
+
+text[[167, 718, 884, 740]]
+A Figura 5.3 ilustra o processo de eliminação de ε-transições para o autômato \(M_7\). 
+
+image[[222, 755, 830, 842]]
+ 
+
+image_caption[[210, 849, 830, 870]]
+<center>Figura 5.3: Eliminação de ε-transições em \(M_7\): \(q_0\) torna-se estado final.</center>

ocr_outputs/deepseek-ocr-2/page-41.md

@@ -0,0 +1,56 @@
+sub_title[[137, 85, 448, 102]]
+## 5.4.1 Exemplo de Eliminação
+
+text[[164, 115, 595, 133]]
+No  \( M_{7} \)  anterior,  \( \delta_{\varepsilon}(q_{0})=\{q_{0},q_{f}\} \) . Calculamos  \( \delta' \) :
+
+equation[[286, 153, 757, 173]]
+ \[ \delta^{\prime}(q_{0},a)=\delta_{\varepsilon}(\delta(q_{0},a)\cup\delta(q_{f},a))=\delta_{\varepsilon}(\emptyset\cup\{q_{f}\})=\{q_{f}\} \] 
+
+equation[[286, 178, 641, 198]]
+ \[ \delta^{\prime}(q_{f},a)=\delta_{\varepsilon}(\delta(q_{f},a))=\delta_{\varepsilon}(\{q_{f}\})=\{q_{f}\} \] 
+
+text[[136, 217, 905, 256]]
+Como  \( \delta_{\varepsilon}(q_{0})\cap\{q_{f}\}\neq\emptyset \) , temos  \( F^{\prime}=\{q_{0},q_{f}\} \) . O AFN resultante aceita  \( \{a\}^{*} \)  sem  \( \varepsilon \) -transições.
+
+text[[186, 270, 642, 288]]
+Exemplo – Eliminação de ε-Transições em  \( M_{8} \) 
+
+text[[153, 298, 650, 317]]
+Para o AFN-ε  \( M_{8} \)  da Figura 5.2 calculemos os fechos-ε:
+
+text[[153, 330, 888, 372]]
+• \(\delta_{\varepsilon}(q_{0})=\{q_{0},q_{1},q_{2}\}\) (pois \(q_{0}\stackrel{\varepsilon}{\rightarrow}q_{1}\stackrel{\varepsilon}{\rightarrow}q_{2}\), e \(q_{0}\stackrel{\varepsilon}{\rightarrow}q_{3}\) com \(q_{3}\) não levando a mais estados por \(\varepsilon\)). Na verdade: \(\delta_{\varepsilon}(q_{0})=\{q_{0},q_{1},q_{2},q_{3}\}\).
+
+text[[153, 386, 319, 404]]
+• \(\delta_{\varepsilon}(q_{1})=\{q_{1},q_{2}\}\)
+
+text[[153, 418, 579, 438]]
+• \(\delta_{\varepsilon}(q_{2})=\{q_{2}\},\quad\delta_{\varepsilon}(q_{3})=\{q_{3}\},\quad\delta_{\varepsilon}(q_{4})=\{q_{4}\}\)
+
+text[[153, 451, 889, 491]]
+Como  \( \delta_{\varepsilon}(q_{0})\cap F=\{q_{2}\}\neq\emptyset \) , o estado  \( q_{0} \)  torna-se final em  \( M_{8}^{\prime} \) , garantindo que  \( \varepsilon \)  é aceita.
+
+sub_title[[137, 522, 598, 541]]
+## 5.5 Equivalência AFN-ε, AFN e AFD
+
+text[[164, 560, 641, 577]]
+Os três modelos são equivalentes em poder expressivo:
+
+equation[[419, 598, 624, 615]]
+ \[  AFD\equiv AFN\equiv AFN-\varepsilon \] 
+
+text[[136, 637, 907, 719]]
+Todos reconhecem exatamente as linguagens regulares. A cadeia de conversão é: AFN-eliminar  \( \varepsilon \)  → AFN subconjuntos → AFD. As  \( \varepsilon \) -transições facilitam construções modulares (união, concatenação, fecho de Kleene de autômatos), sendo amplamente usadas na construção de Thompson para converter expressões regulares em autômatos (SIPSER, 2007).
+
+text[[136, 723, 907, 783]]
+Embora não ampliem o poder de reconhecimento, as  \( \varepsilon \) -transições são uma ferramenta de projeto valiosa que simplifica a composição de autômatos e a demonstração de propriedades teóricas (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+sub_title[[186, 797, 430, 815]]
+## Cadeia de Equivalências
+
+text[[153, 825, 890, 864]]
+A equivalência completa entre os formalismos para linguagens regulares pode ser resumida como:
+
+equation[[252, 885, 792, 903]]
+ \[  ER\longleftrightarrow AFN-\varepsilon\longleftrightarrow AFN\longleftrightarrow AFD\longleftrightarrow Gramática Regular \]

ocr_outputs/deepseek-ocr-2/page-42.md

@@ -0,0 +1,44 @@
+text[[155, 81, 690, 100]]
+Cada seta representa um algoritmo de conversão construtivo: 
+
+text[[155, 113, 554, 133]]
+- ER → AFN-ε: Construção de Thompson 
+
+text[[155, 145, 576, 166]]
+- AFN-ε → AFN: Eliminação de ε-transições 
+
+text[[155, 179, 572, 199]]
+- AFN → AFD: Construção de subconjuntos 
+
+text[[155, 213, 505, 232]]
+- AFD → ER: Eliminação de estados 
+
+text[[155, 245, 725, 266]]
+- AFD ↔ Gram. Regular: Correspondência estados-variáveis 
+
+text[[155, 280, 688, 300]]
+Esses algoritmos são detalhados ao longo dos capítulos 3 a 6. 
+
+text[[139, 309, 905, 351]]
+A Tabela 5.1 apresenta um resumo comparativo dos três modelos de autômatos finitos, destacando suas características e aplicações típicas. 
+
+table_caption[[227, 362, 816, 382]]
+Tabela 5.1: Resumo comparativo dos modelos de autômatos finitos. 
+
+table[[139, 394, 904, 561]]
+<table>ModeloPrincipais CaracterísticasAplicação TípicaAFDDeterminístico, função total, computação únicaImplementação direta, simulação eficienteAFNNão-determinístico, múltiplas transiçõesProjeto de reconhecimentos, especificaçãoAFN-εε-transições, construção modularConstrução de Thompson, fechamento</table>
+
+sub_title[[139, 585, 522, 605]]
+### 5.5.1 Aplicações Práticas dos AFN-ε 
+
+text[[139, 616, 904, 743]]
+As ε-transições são indispensáveis em diversas aplicações práticas da teoria dos autômatos. Na construção de compiladores, a **construção de Thompson** (detalhada no Capítulo 6) utiliza AFN-ε como formato intermediário na conversão de expressões regulares para autômatos. Cada operação da expressão regular (união, concatenação, fecho) é traduzida em um padrão de composição que emprega ε-transições para conectar subautômatos (RAMOS; NETO; VEGA, 2009). 
+
+text[[139, 744, 905, 850]]
+Além disso, as ε-transições facilitam a demonstração construtiva de propriedades de fechamento. Para provar que linguagens regulares são fechadas sob união, por exemplo, basta criar um novo estado inicial com ε-transições para os estados iniciais dos dois autômatos originais. Construções análogas funcionam para concatenação e fecho de Kleene (HOPCROFT; ULLMAN; MOTWANI, 2002). 
+
+sub_title[[186, 860, 703, 879]]
+#### Exemplo – Fechamento sob União com ε-Transições 
+
+text[[155, 888, 888, 910]]
+Dados dois AFDs \(M_A\) (para \(L_A\)) e \(M_B\) (para \(L_B\)), podemos construir um AFN-ε para

ocr_outputs/deepseek-ocr-2/page-43.md

@@ -0,0 +1,77 @@
+text[[157, 81, 405, 101]]
+\(L_A \cup L_B\) da seguinte forma: 
+
+text[[181, 113, 500, 135]]
+1. Crie um novo estado inicial \(q_{novo}\). 
+
+text[[181, 145, 888, 188]]
+2. Adicione \(\varepsilon\)-transições de \(q_{novo}\) para \(q_{0A}\) (estado inicial de \(M_A\)) e para \(q_{0B}\) (estado inicial de \(M_B\)). 
+
+text[[181, 201, 475, 221]]
+3. Os estados finais são \(F_A \cup F_B\). 
+
+text[[156, 234, 888, 275]]
+O AFN-\(\varepsilon\) resultante aceita \(w\) se e somente se \(w \in L_A\) ou \(w \in L_B\), pois a \(\varepsilon\)-transição inicial “escolhe” qual sub-autômato simular. 
+
+sub_title[[137, 307, 428, 328]]
+## 5.6 Lista de Exercícios 
+
+text[[157, 344, 519, 365]]
+1. Qual a definição do fecho vazio \(\delta_\varepsilon(q)\)? 
+
+text[[197, 376, 270, 398]]
+(a) \(\{q\}\) 
+
+text[[197, 404, 293, 425]]
+(b) \(\delta(q, \varepsilon)\) 
+
+text[[197, 426, 500, 455]]
+(c) \(\{q\} \cup \delta(q, \varepsilon) \cup (\bigcup_{p \in \delta(q, \varepsilon)} \delta_\varepsilon(p))\) 
+
+text[[197, 458, 320, 480]]
+(d) \(\delta^*(q), \varepsilon\) 
+
+text[[197, 485, 342, 508]]
+(e) \(\bigcup_{a \in \Sigma} \delta(q, a)\) 
+
+text[[157, 519, 468, 540]]
+2. No AFN-\(\varepsilon\) \(M_7\), qual é \(\delta_\varepsilon(\{q_0\})\)? 
+
+text[[197, 551, 290, 572]]
+(a) Vazio 
+
+text[[197, 579, 280, 600]]
+(b) \(\{q_0\}\) 
+
+text[[197, 607, 305, 629]]
+(c) \(\{q_0, q_f\}\) 
+
+text[[197, 634, 280, 655]]
+(d) \(\{q_f\}\) 
+
+text[[197, 661, 330, 682]]
+(e) \(\{q_0, q_f, q_1\}\) 
+
+text[[157, 695, 565, 715]]
+3. Qual expressão descreve \(\delta^*\) em um AFN-\(\varepsilon\)? 
+
+text[[197, 728, 457, 750]]
+(a) \(\delta^*(P, wa) = \delta(\delta^*(P, w), a)\) 
+
+text[[197, 755, 430, 777]]
+(b) \(\delta^*(P, \varepsilon) = \bigcup_{q \in P} \delta(q, \varepsilon)\) 
+
+text[[197, 782, 530, 803]]
+(c) \(\delta^*(P, wa) = \delta_\varepsilon(\delta^*(P, w)) \cup \delta^*(P, a)\) 
+
+text[[197, 810, 384, 831]]
+(d) \(\delta^*(P, \varepsilon) = \delta(P, \varepsilon)\) 
+
+text[[197, 836, 640, 858]]
+(e) \(\delta^*(P, wa) = \delta_\varepsilon(\{r \mid \exists s \in \delta^*(P, w) : r \in \delta(s, a)\})\) 
+
+text[[157, 871, 496, 891]]
+4. Ao eliminar \(\varepsilon\)-transições, \(\delta'(p, a)\) é: 
+
+text[[197, 903, 295, 924]]
+(a) \(\delta(p, a)\)

ocr_outputs/deepseek-ocr-2/page-44.md

@@ -0,0 +1,11 @@
+text[[198, 84, 275, 101]]
+(b)  \( \delta_{\varepsilon}(p) \) 
+
+text[[198, 108, 539, 133]]
+(c)  \( \bigcup_{q\in\delta_{\varepsilon}(p)}\delta(q,a)\cup\delta_{\varepsilon}\left(\bigcup_{q\in\delta_{\varepsilon}(p)}\delta(q,a)\right) \) 
+
+text[[198, 138, 318, 156]]
+(d)  \( \delta_{\varepsilon}(\delta(p,a)) \) 
+
+text[[199, 165, 349, 186]]
+(e)  \( \bigcup_{q\in\delta(p,a)}\delta_{\varepsilon}(q) \)

ocr_outputs/deepseek-ocr-2/page-45.md

@@ -0,0 +1,23 @@
+sub_title[[137, 87, 600, 109]]
+## 6 EXPRESSÕES REGULARES
+
+text[[136, 139, 907, 283]]
+Enquanto os autômatos finitos são modelos operacionais de reconhecimento, as expressões regulares (ER) oferecem uma notação algébrica e declarativa para denotar linguagens regulares. Amplamente utilizadas em ferramentas como grep, sed e em linguagens de programação, as ERs permitem descrever padrões de forma compacta e legível. A importância teórica reside no Teorema de Kleene: a classe de linguagens denotadas por expressões regulares é exatamente a classe das linguagens regulares (MENEZES, 2011).
+
+text[[136, 287, 907, 368]]
+Por exemplo, a linguagem de todas as cadeias sobre  \( \{a,b\} \)  que contêm a subcadeia ab pode ser descrita simplesmente como  \( (a+b)^{*}ab(a+b)^{*} \) , dispensando a construção explícita de estados e transições. Essa condição é uma das principais vantagens das ERs (SIPSER, 2007).
+
+text[[136, 373, 907, 475]]
+Na prática, expressões regulares são onipresentes na computação moderna. Validação de e-mails, busca textual avançada, filtragem de logs, definição de tokens em compiladores e roteamento de URLs em servidores web são apenas algumas das aplicações que dependem diretamente de expressões regulares. Compreender sua fundamentação teórica permite ao profissional utilizá-las com maior segurança e eficiência (RAMOS; NETO; VEGA, 2009).
+
+sub_title[[137, 503, 402, 522]]
+## 6.1 Definição Formal
+
+text[[137, 540, 906, 642]]
+Seja  \( \Sigma \)  um alfabeto. Uma expressão regular sobre  \( \Sigma \)  e a linguagem que ela gera,  \( L(r) \) , são definidas recursivamente. Os casos base são:  \( \emptyset \)  (gera a linguagem vazia),  \( \varepsilon \)  (gera  \( \{\varepsilon\} \) ) e cada  \( a \in \Sigma \)  (gera  \( \{a\} \) ). Os casos recursivos: se r e s são ERs, então  \( (r + s) \)  gera  \( L(r) \cup L(s) \)  (união),  \( (r \cdot s) \)  gera  \( L(r) \cdot L(s) \)  (concatenação) e  \( (r^{*}) \)  gera  \( (L(r))^{*} \)  (fecho de Kleene).
+
+text[[136, 647, 906, 707]]
+O operador de concatenação é frequentemente omitido (rs significa  \( r \cdot s \) ). A notação  \( r^{+} \) abrevia  \( r \cdot r^{*} \)  (uma ou mais repetições). Parênteses podem ser omitidos conforme a precedência dos operadores (HOPCROFT; ULLMAN; MOTWANI, 2002).
+
+text[[137, 710, 905, 749]]
+A Tabela 6.1 apresenta os elementos básicos da definição, reforçando a correspondência entre cada expressão e a linguagem que ela denota.

ocr_outputs/deepseek-ocr-2/page-46.md

@@ -0,0 +1,47 @@
+figure_title[[272, 82, 772, 99]]
+Tabela 6.1: Expressões regulares: casos base e recursivos.
+
+table[[140, 111, 902, 319]]
+<table>Expressão rLinguagem L(r)Descrição∅∅Linguagem vazia (nenhuma cadeia)ε{ε}Apenas a cadeia vaziaa (com a ∈ Σ){a}Apenas o símbolo ar + sL(r) ∪ L(s)Uniãor · sL(r) · L(s)Concatenaçãor*(L(r))*Fecho de Kleene (zero ou mais)r+L(r) · (L(r))*Fecho positivo (uma ou mais)</table>
+
+sub_title[[137, 353, 532, 372]]
+## 6.2 Precedência dos Operadores
+
+text[[137, 390, 905, 449]]
+A precedência, da mais alta para a mais baixa, é: (1) fecho de Kleene (*); (2) concatenação; (3) união (+). Assim,  \( ab^{*} \)  significa  \( a(b^{*}) \) ,  \( a + bc \)  significa  \( a + (bc) \)  e  \( a + b^{*}c \)  significa  \( a + ((b^{*})c) \) .
+
+text[[137, 454, 905, 493]]
+Essa convenção permite escrever expressões de forma mais enxuta. Por exemplo,  \( ab^{*}+c \)  equivale a  \( (a(b^{*})) + c \)  e gera a linguagem  \( \{ab^{n} \mid n \geq 0\} \cup \{c\} \)  (SIPSER, 2007).
+
+sub_title[[186, 507, 671, 525]]
+## Exemplo – Aplicação das Regras de Precedência
+
+text[[155, 536, 585, 554]]
+Analise a expressão  \( ab^{*}a + ba^{*}b \)  sobre  \( \Sigma = \{a, b\} \) .
+
+text[[186, 558, 500, 574]]
+Aplicando as regras de precedência:
+
+text[[179, 590, 433, 607]]
+1. Primeiro, o fecho:  \( b^{*} \)  e  \( a^{*} \) .
+
+text[[178, 623, 555, 641]]
+2. Depois, a concatenação:  \( a(b^{*})a \)  e  \( b(a^{*})b \) .
+
+text[[179, 656, 559, 674]]
+3. Finalmente, a união:  \( (a(b^{*})a) + (b(a^{*})b) \) .
+
+text[[186, 689, 386, 707]]
+A linguagem gerada é:
+
+equation[[186, 727, 856, 746]]
+ \[ L=\{ab^{n}a\mid n\geq0\}\cup\{ba^{n}b\mid n\geq0\}=\{aa,aba,abba,\cdots\}\cup\{bb,bab,baab,\cdots\} \] 
+
+text[[155, 767, 887, 806]]
+São cadeias que começam e terminam com o mesmo símbolo, com zero ou mais repetições do outro símbolo no meio.
+
+sub_title[[137, 836, 559, 854]]
+## 6.2.1 Exemplos de Expressões Regulares
+
+text[[166, 866, 608, 886]]
+A Tabela 6.2 apresenta exemplos sobre  \( \Sigma=\{a,b\} \) .

ocr_outputs/deepseek-ocr-2/page-47.md

@@ -0,0 +1,50 @@
+figure_title[[320, 82, 722, 99]]
+Tabela 6.2: Exemplos de expressões regulares.
+
+table[[140, 112, 904, 254]]
+<table>ERLinguagem\( (a + b)^{*} \)\( \Sigma^{*} \)  — todas as cadeias\( a(a + b)^{*} \)Cadeias que começam com a\( b^{*}ab^{*}ab^{*} \)Cadeias com exatamente dois a&#x27;s\( a^{*}b^{*} \)Cadeias da forma  \( a^{n}b^{m} \)\( ((a + b)(a + b))^{*} \)Cadeias de comprimento par</table>
+
+sub_title[[184, 288, 720, 305]]
+## Exemplo – Construção de ERs para Padrões Comuns
+
+text[[155, 316, 688, 335]]
+Sobre \(\Sigma=\{0,1\}\), construa ERs para as seguintes linguagens:
+
+text[[185, 338, 642, 356]]
+(a) Cadeias que começam com 0 e terminam com 1:
+
+equation[[475, 377, 568, 395]]
+ \[ 0(0+1)^{*}1 \] 
+
+text[[154, 416, 888, 455]]
+Precisamos de pelo menos dois símbolos. O primeiro é 0, o último é 1, e no meio pode haver qualquer cadeia.
+
+text[[186, 458, 568, 476]]
+(b) Cadeias de comprimento exatamente 3:
+
+equation[[430, 497, 613, 515]]
+ \[ (0+1)(0+1)(0+1) \] 
+
+text[[186, 536, 609, 554]]
+(c) Cadeias que não contêm 00 como subcadeia:
+
+equation[[454, 574, 590, 593]]
+ \[ 1^{*}(01^{+})^{*}(\varepsilon+0) \] 
+
+text[[155, 614, 886, 632]]
+A ideia é que após cada 0 deve haver pelo menos um 1 (exceto possivelmente no final).
+
+text[[186, 635, 506, 653]]
+(d) Cadeias com número par de 0's:
+
+equation[[461, 673, 582, 692]]
+ \[ (1^{*}01^{*}01^{*})^{*}1^{*} \] 
+
+text[[155, 712, 800, 731]]
+Os 0's sempre aparecem em pares, com qualquer número de 1's entre eles.
+
+sub_title[[137, 764, 381, 784]]
+## 6.3 Leis Algébricas
+
+text[[137, 801, 906, 842]]
+Duas ERs r e s são equivalentes (r = s) se  \( L(r) = L(s) \) . As principais leis são apresentadas na Tabela 6.3

ocr_outputs/deepseek-ocr-2/page-48.md

@@ -0,0 +1,32 @@
+figure_title[[295, 82, 750, 100]]
+Tabela 6.3: Leis algébricas das expressões regulares.
+
+table[[140, 112, 904, 468]]
+<table>LeiExpressãoComutatividade da união\( r + s = s + r \)Associatividade da união\( (r + s) + t = r + (s + t) \)Associatividade da concat.\( (rs)t = r(st) \)Elemento neutro da união\( r + \emptyset = r \)Elemento neutro da concat.\( r\varepsilon = \varepsilon r = r \)Elemento absorvente\( r\emptyset = \emptyset r = \emptyset \)Distributividade\( r(s + t) = rs + rt \)Idempotência da união\( r + r = r \)Definição de  \( r^{*} \)\( r^{*} = \varepsilon + r \cdot r^{*} \)Fecho do fecho\( (r^{*})^{*} = r^{*} \)Absorção\( \emptyset^{*} = \varepsilon \)</table>
+
+text[[137, 491, 906, 551]]
+A concatenação não é comutativa:  \( ab \neq ba \) . Essas leis permitem simplificar ERs; por exemplo,  \( a + a(b + a)^{*} = a(\varepsilon + (b + a)^{*}) = a(b + a)^{*} \) , usando  \( \varepsilon + r^{*} = r^{*} \)  (MENEZES, 2011).
+
+sub_title[[188, 563, 578, 581]]
+## Exemplo – Simplificação Passo a Passo
+
+text[[155, 592, 670, 610]]
+Simplifique a expressão  \(  r = (a + b)^{*} a (\varepsilon + b) (\varepsilon + a) (a + b)^{*}  \) .
+
+text[[154, 613, 890, 696]]
+Observe que  \( (a + b)^{*} \)  no início aceita qualquer prefixo, e  \( (a + b)^{*} \)  no final aceita qualquer sufixo. A parte central  \( a(\varepsilon + b)(\varepsilon + a) \)  gera as cadeias  \( \{a, ab, aa, aba\} \) . Como essas cadeias começam com a e são subcadeias de qualquer cadeia aceita, a expressão completa aceita qualquer cadeia que contenha a como subcadeia:
+
+equation[[427, 715, 615, 734]]
+ \[ r=(a+b)^{*}a(a+b)^{*} \] 
+
+text[[154, 754, 889, 795]]
+Essa simplificação usa o fato de que  \( (a + b)^{*} \cdot X \cdot (a + b)^{*} \)  absorve qualquer extensão de X, desde que a condição essencial (conter a) seja preservada.
+
+sub_title[[186, 824, 514, 841]]
+## Leis Frequentemente Esquecidas
+
+text[[155, 852, 700, 871]]
+Algumas identidades úteis que são frequentemente esquecidas:
+
+text[[155, 884, 538, 904]]
+•  \( \varepsilon + r^{*} = r^{*} \)  (pois  \( \varepsilon \in L(r^{*}) \)  por definição)

ocr_outputs/deepseek-ocr-2/page-49.md

@@ -0,0 +1,32 @@
+text[[155, 81, 536, 100]]
+•  \( r^{+} = rr^{*} = r^{*}r \)  (uma ou mais repetições) 
+
+text[[155, 113, 624, 133]]
+•  \( r^{*} = \varepsilon + r^{+} \)  (zero ou mais = vazio + uma ou mais) 
+
+text[[155, 146, 603, 167]]
+•  \( (r + s)^{*} = (r^{*}s^{*})^{*} \)  (intercalar repetições de r e s) 
+
+text[[155, 180, 694, 199]]
+•  \( r^{*}r^{*} = r^{*} \)  (concatenar dois fechos é o mesmo que um fecho) 
+
+sub_title[[137, 232, 770, 252]]
+## 6.4 Teorema de Kleene: ER e Linguagens Regulares 
+
+text[[137, 270, 907, 330]]
+O Teorema de Kleene garante que uma linguagem é regular se e somente se é de- notada por alguma ER. A demonstração tem duas direções (HOPCROFT; ULLMAN; MOTWANI, 2002): 
+
+text[[137, 348, 907, 410]]
+• ER ⇒ Autômato (Construção de Thompson): cada ER é convertida recursivamente em um AFN-ε. Os casos base (∅, ε, a) geram autômatos triviais. União, concatenação e fecho são obtidos conectando sub-autômatos por ε-transições. 
+
+text[[137, 425, 907, 464]]
+• Autômato ⇒ ER (Eliminação de estados ou Lema de Arden): remove-se progressi- vamente estados do autômato, substituindo transições por expressões regulares. 
+
+text[[137, 483, 907, 585]]
+Junto com os resultados dos capítulos anteriores, isso estabelece a tríplice equiva- lência: ER ≡ Autômatos Finitos ≡ Gramáticas Regulares. Na prática, ERs são convenientes para descrever padrões, autômatos para implementar reconhecedores e gra- máticas para gerar cadeias. A implementação eficiente dessas conversões é fundamental para ferramentas de busca textual e analisadores léxicos (RAMOS; NETO; VEGA, 2009). 
+
+sub_title[[137, 610, 466, 627]]
+## 6.4.1 Construção de Thompson 
+
+text[[137, 640, 907, 700]]
+A construção de Thompson converte uma expressão regular em um AFN-ε de forma recursiva. Cada operador (união, concatenação, fecho) corresponde a um padrão de com- posição de sub-autômatos. A Figura 6.1 ilustra os três padrões fundamentais.

ocr_outputs/deepseek-ocr-2/page-50.md

@@ -0,0 +1,41 @@
+image[[256, 84, 800, 320]]
+
+
+figure_title[[137, 336, 905, 371]]
+Figura 6.1: Construção de Thompson: padrões para união  \( (r + s) \) , concatenação  \( (rs) \)  e fecho  \( (r^{*}) \) .
+
+text[[137, 397, 906, 479]]
+Cada sub-autômato produzido pela construção de Thompson possui exatamente um estado inicial (sem transições de entrada) e um estado final (sem transições de saída). Essa propriedade garante que os sub-autômatos podem ser compostos sem interferência, preservando a correção da construção (SIPSER, 2007).
+
+sub_title[[186, 493, 703, 511]]
+## Exemplo – Construção de Thompson para  \( (a + b)^{*}ab \) 
+
+text[[152, 522, 797, 540]]
+Para a expressão  \( (a + b)^{*}ab \) , a construção é realizada de dentro para fora:
+
+text[[153, 545, 889, 582]]
+Passo 1: Construa o AFN-ε para a (um estado inicial, transição a, um estado final).
+
+text[[184, 587, 645, 605]]
+Passo 2: Construa o AFN-ε para b (analogamente).
+
+text[[184, 608, 610, 625]]
+Passo 3: Combine com união para obter  \( a + b \) .
+
+text[[184, 629, 700, 647]]
+Passo 4: Aplique o fecho de Kleene para obter  \( (a + b)^{*} \) .
+
+text[[184, 651, 710, 668]]
+Passo 5: Concatenem com o AFN para a, obtendo  \( (a + b)^{*}a \) .
+
+text[[184, 672, 716, 689]]
+Passo 6: Concatenem com o AFN para b, obtendo  \( (a + b)^{*}ab \) .
+
+text[[153, 693, 890, 755]]
+O resultado é um AFN-ε que pode ser convertido em AFD pela eliminação de ε-transições seguida da construção de subconjuntos. Esse é exatamente o procedimento que ferramentas como lex utilizam internamente.
+
+sub_title[[137, 784, 580, 802]]
+## 6.4.2 Limitações das Expressões Regulares
+
+text[[137, 814, 906, 896]]
+ERs não podem descrever linguagens que exigem “memória ilimitada”:  \( \{a^{n}b^{n} \mid n \geq 0\} \)  (contar e comparar),  \( \{ww^{R}\} \)  (palíndromos) e  \( \{a^{n^{2}}\} \)  (comprimento quadrado perfeito) são exemplos de linguagens não regulares. A prova formal utiliza o Lema do Bombeamento (SIPSER, 2007).