Apostila de Linguagens Formais 4.0

AUTARQUIA EDUCACIONAL DO VALE DO SÃO FRANCISCO – AEVSF
FACULDADE DE CIÊNCIAS APLICADAS E SOCIAIS DE PETROLINA – FACAPE

CIÊNCIAS DA COMPUTAÇÃO
APOSTILA DE LINGUAGENS FORMAIS

VERSÃO 4.0
MSc. Roberto Tenorio Figueiredo
PETROLINA, 2015
SUMÁRIO
PREFÁCIO ......................................................................................................................................... 4
1. INTRODUÇÃO .......................................................................................................................... 5
1.1. HISTÓRICO ........................................................................................................................ 5
2. CONCEITOS BÁSICOS ........................................................................................................... 7

2.1. CADEIA (C) ............................................................................................................................. 8
2.1.1. PROPRIEDADES DA CADEIA ................................................................................... 8
2.2. LINGUAGENS (L) ............................................................................................................ 10
2.2.1. O PODER DAS LINGUAGENS ................................................................................. 10
2.2.2. PROPRIEDADES DAS LINGUAGENS .................................................................... 10
2.3. EXPRESSÕES REGULARES .......................................................................................... 12
EXERCÍCIOS ................................................................................................................................ 13
3. AUTÔMATOS FINITOS ........................................................................................................ 14

3.1. CONCEITO ....................................................................................................................... 15
3.2. CONVENÇÕES ................................................................................................................. 16
3.3. DETERMINISMO ............................................................................................................. 17
3.4. AUTÔMATO FINITO DETERMINÍSTICO .................................................................... 17
3.5. REGRA DA CADEIA MÍNIMA ....................................................................................... 18
3.5.1. LEMAS DA REGRA DA CADEIA MÍNIMA ........................................................... 20
3.6. REGRA DA TRANSFORMAÇÃO................................................................................... 25
3.6.1. AUTÔMATO FINITO NÃO-DETERMINÍSTICO .................................................... 25
3.6.2. ALGORITMO DE TRANSFORMAÇÃO................................................................... 26
3.7. MINIMIZAÇÃO DE AUTÔMATOS ............................................................................... 28
3.8. LINGUAGENS NÃO-REGULARES ............................................................................... 31
4. GRAMÁTICAS ........................................................................................................................ 32
1. CONCEITO ............................................................................................................................ 32
2. CLASSES DE GRAMÁTICAS .............................................................................................. 32
3. GRAMÁTICAS COM ESTRUTURA DE FRASE ................................................................... 33
4. GRAMÁTICAS LIVRES-DE-CONTEXTO ............................................................................. 35
4.1. SEPARAÇÃO DE VARIÁVEIS DAS GRAMÁTICAS LIVRES-DE-CONTEXTO ....... 36
4.2. LEMAS DAS GRAMÁTICAS LIVRES-DE-CONTEXTO .............................................. 37
4.3. FORMAS NORMAIS DAS GRAMÁTICAS LIVRES-DE-CONTEXTO ........................ 40
5. GRAMÁTICAS REGULARES ................................................................................................. 43
5.1. SEPARAÇÃO DE VARIÁVEIS DAS GRAMÁTICAS REGULARES ........................... 43
5.2. PROPRIEDADES DAS GRAMÁTICAS REGULARES .................................................. 45
6. GRAMÁTICAS SENSÍVEIS-AO-CONTEXTO ...................................................................... 48
6.1. SEPARAÇÃO DE VARIÁVEIS DAS GRAMÁTICAS SENSÍVEIS-AO-CONTEXTO. 48
2
5. AUTÔMATOS A PILHA ........................................................................................................ 51
1. CONCEITO ............................................................................................................................ 51
2. CONVENÇÕES ...................................................................................................................... 52
3. DETERMINISMO .................................................................................................................. 53
4. CONSTRUÇÃO DOS AUTÔMATOS A PILHA .................................................................. 53
5. LEMAS DO AUTÔMATO A PILHA .................................................................................... 55
6. TRANSFORMAÇÃO DE GRAMÁTICAS LIVRES-DE-CONTEXTO EM AUTÔMATOS
A PILHA ........................................................................................................................................ 59
6. MÁQUINAS DE TURING .......................................................................................................... 61

1. HISTÓRICO ........................................................................................................................... 61
2. CONCEITO ............................................................................................................................ 62
2.1. Conceito Informal da Máquina de Turing ......................................................................... 62
2.2. Conceito Formal da Máquina de Turing ........................................................................... 63
3. CARACTERÍSTICAS DA MÁQUINA DE TURING PADRÃO ......................................... 63
4. CONVENÇÕES ...................................................................................................................... 63
5. TESE DE CHURCH-TURING ............................................................................................... 64
6. O PROBLEMA DA PARADA ............................................................................................... 65
7. CONSTRUÇÃO DA MÁQUINA DE TURING .................................................................... 66
7.1 – Máquinas de Turing como Reconhecedor de Linguagens ................................................ 66
7.2 – Máquinas de Turing como Operador Algébrico ............................................................... 68
8. VARIAÇÕES DA MÁQUINA DE TURING PADRÃO ....................................................... 76
9. MÁQUINA DE TURING UNIVERSAL ............................................................................... 78
10. BINARIZAÇÃO DAS MÁQUINAS DE TURING .......................................................... 79
REFERÊNCIAS ............................................................................................................................... 81
ANEXOS ........................................................................................................................................... 82
1. TABELA ASCII ..................................................................................................................... 82
2. OS MESTRES......................................................................................................................... 84
APÊNDICE 01: ALGORITMO SOBRE AUTÔMATOS FINITOS .......................................... 86
APÊNDICE 02: ALGORITMOS SOBRE MÁQUINAS DE TURING ...................................... 87
APÊNDICE 03: BINÁRIO REDUZIDO DA MÁQUINA DE TURING UNIVERSAL ........... 90
3
PREFÁCIO
Os textos existentes nesta apostila são de minha autoria e de vários autores renomados na área de
linguagens formais, como Noam Chomsky, John Hopcroft, Benedito Acióly, entre outros. Alguns
exemplos e analogias foram adicionados aos textos originais para facilitar a compreensão do assunto.
Este material não se propõe a substituir a riqueza presente nos livros publicados pelos autores
mencionados, mas sim, servir como apoio às aulas da disciplina de Linguagens Formais e Teoria da
Computação do Curso de Ciência da Computação da Facape.
Dada a grande quantidade de trechos extraídos praticamente na íntegra de alguns livros, fica
impraticável referenciar todos eles. Em compensação, os livros citados na bibliografia, ao final desta
apostila, constituem as fontes principais do texto que a partir daqui se inicia.
Espero que realmente este grande “resumo” possa ser útil para que os alunos da disciplina
compreendam os aspectos mais importantes das Linguagens Formais e da Teoria da Computação.
4
APOSTILA DE LINGUAGENS FORMAIS – INTRODUÇÃO Prof. TENORIO
1. INTRODUÇÃO
A teoria da computação é um estudo teórico do funcionamento interno de um computador. Visa

permitir o surgimento de novas tecnologias e auxilia a repassar o conhecimento, tornando-o livre de
ambiguidades. As linguagens formais compõem a Teoria da Computação.
Uma linguagem é um meio de comunicação, formada por um conjunto de palavras e de regras

gramaticais que permitem combinar as palavras em sentenças sintaticamente corretas. Uma
linguagem é dita formal quando pode ser representada através de um sistema com sustentação
matemática (modelos matemáticos relacionados a uma linguagem). A Linguística Formal
compreende a representação da sintaxe (estrutura) e da semântica (significado) das sentenças de uma
linguagem. Nesta disciplina será abordada somente a estrutura sintática das linguagens. Os modelos
matemáticos possibilitam validar ou não uma determinada sequência de informações, ou seja, saber
se uma sequência de informações pertence a uma determinada linguagem.
A importância dessa teoria na Ciência da Computação é dupla: tanto apoia diversos aspectos teóricos
da Ciência da Computação, como a decidibilidade, computabilidade, complexidade computacional,
entre outros, como fundamenta diversas aplicações computacionais tais como processamento de
linguagens de programação, reconhecimento de padrões, modelagem de sistemas, etc.
1.1. HISTÓRICO
O homem sempre tentou explicar a natureza utilizando a matemática. Na antiga Grécia, pode-se ver
isso em desenhos de algoritmos feitos por Euclides, no século III a.C., muitos antes do termo
algoritmo ser criado. Na antiga Babilônia, existem estudos sobre a complexidade de problemas e
como reduzi-los, em problemas menores e mais fáceis de serem resolvidos, porém a Teoria da
Computação, como nós a conhecemos, teve início nos primeiros anos do século XX, antes da
invenção dos modernos computadores eletrônicos.
Um marco inicial da Teoria da Computação é o problema proposto por David Hilbert, o qual consistia
em encontrar um procedimento para demonstrar se uma dada fórmula no cálculo de preposições de
primeira ordem era válida ou não. (Fórmula do cálculo de predicados no qual a quantificação é restrita
às variáveis individuais). Em 1931, Kurt Gödel, em seu “teorema da não completude”, demonstrou
que o problema da mecanização do processo de prova de teoremas não tinha solução. A classe de
funções usada por Gödel foi à classe das funções primitivas recursivas definidas anteriormente por
Dedekind em 1888. Embora não tenha sido proposital, Gödel foi (aparentemente) o primeiro a
identificar um formalismo para definir a noção de procedimento efetivo. Em 1936, Alonzo Church
usou dois formalismos para mostrar que o problema de Hilbert não tem solução: λ-calculus (Church,
1936) e funções recursivas (Kleene, 1936). Também em 1936, Alan Turing propôs um formalismo
para a representação de procedimentos efetivos. Esse foi o primeiro trabalho a identificar programas
escritos para uma “máquina computacional automática”, como noções intuitivas de efetividade.
Desde então, muitos outros formalismos foram propostos, os quais possuem o mesmo poder
computacional que as funções recursivas ou Cálculo Lambda:
• Máquina de Turing (1936);

• Sistema Canônico de Post (1943);
• Algoritmo de Markov e a Linguagem Snobol (1954);
5
APOSTILA DE LINGUAGENS FORMAIS – INTRODUÇÃO Prof. TENORIO
• Máquinas de Registradores (1963);

• RASP (Random Acess Stored Programs - 1964).
Em resumo, os estudiosos estavam tentando descobrir quais problemas matemáticos poderiam ser
resolvidos por um método simples, e quais não poderiam. O primeiro passo estava em definir o
significado de um "método simples" para resolver o problema. Em outras palavras, eles precisavam
de um modelo formal de computação. Diversos modelos foram propostos e são alguns destes modelos
que iremos estudar ao longo desta apostila.
6
APOSTILA DE LINGUAGENS FORMAIS – CONCEITOS BÁSICOS Prof. TENORIO
2. CONCEITOS BÁSICOS
Na computação, todos os dados que você vê na tela de seu monitor são gerados a partir da presença
(1) ou ausência (0) de energia nos circuitos lógicos. Essa energia é convertida em unidades, que serão
utilizadas pelo hardware para permitir a execução de softwares. Tudo que pode ser projetado via
hardware, pode ser projetado via software, utilizando-se apenas quatro comandos básicos: a
atribuição, a soma, a condição (if) e o deslocamento (jump), que altera a sequência corrente de
execução dos comandos.
Para facilitar a programação, essas unidades deveriam representar símbolos conhecidos, daí vem o
conceito de Caractere.
CARACTERE: é uma entidade abstrata básica que não é definida formalmente;
Um exemplo de caracteres são as letras e os dígitos. Como existem infinitos caracteres (símbolos) no
universo, foi necessário limitar sua quantidade a fim de permitir seu uso nos computadores. Para isso,
foram criadas tabelas de símbolos, dito válidos, que poderiam ser utilizados. A tabela mais usada e
conhecida é chamada de tabela ASCII (American Standard Code for Information Interchange –
Código Americano Padrão para o Intercâmbio de Informações), que contém 256 caracteres e associa
um número sequencial a cada caractere que pode ser utilizado no computador (válidos). Na tabela
ASCII, os caracteres correspondentes a valores de 0 a 31 são códigos de controle, de 32 a 127 são
caracteres padrões e de 128 a 255, podem variar de S.O. (Sistema Operacional) para S.O. A tabela
ASCII completa pode ser conferida no final desta apostila.
Para o computador, trabalhar com 256 caracteres é perfeito, porém, nas atividades do dia-a-dia, não
é interessante para o ser humano trabalhar com essa quantidade, até porque o computador precisa
reservar alguns caracteres para uso próprio, daí vem o conceito de alfabeto.
ALFABETO (∑): é o conjunto finito de símbolos distintos e indivisíveis de qualquer natureza.
Na Teoria da Computação, podemos afirmar que alfabeto é um subconjunto da tabela ASCII. Um

alfabeto é denotado pelo símbolo ∑. Um exemplo clássico é o alfabeto romano composto pelos
símbolos que chamamos de letras {a, b, c, d, e,..., z}. Um alfabeto em particular, pertinente à teoria
dos conjuntos é o Alfabeto Binário {0,1}. Um conjunto vazio também é considerado um alfabeto.
Exemplos: Σ = {0, 1, 2, …, 9}, Σ = {a, b, …, z}, Σ = {0,1}, Σ = {A, a, E, e, I, i, O, o, U, u}
7
2.1. CADEIA (C)
Uma Cadeia, sobre um alfabeto, é uma sequência qualquer de símbolos que pertença a este alfabeto,
ou seja, é uma sequência de zero ou mais símbolos do alfabeto justapostos. Uma Cadeia de
Símbolos Finita é usualmente denominada de Palavra. Uma cadeia é denotada pelo símbolo C.
Atenção: Caso uma cadeia seja formada por algum símbolo que não faça parte do alfabeto
corrente, dizemos que trata-se de uma cadeia inválida.
Exemplo 01: Exemplos de cadeia no alfabeto Σ = {a, b, c}
C1 = aab C2 = bacb C3 = b C4 = aaaccaab C5 = ccaa
Atenção: Por exemplo, a cadeia “C6 = acacadaa” é uma cadeia inválida, ou seja, não é uma aceita no
alfabeto do exemplo, por possuir um caractere que não existe no alfabeto da questão, no caso a letra
‘d’.
2.1.1. PROPRIEDADES DA CADEIA
1. Tamanho ou Comprimento: é a quantidade de caracteres que compõem uma cadeia sejam

eles repetidos ou não. É denotado por |x|.
Exemplo 02: Exemplos (baseados no Exemplo 01) de tamanho de cadeia:
| C1 | = 3 | C2 | = 4 | C3 | = 1 | C4 | = 8 | C5 | = 4 | C6 | =
Atenção: Caso se queira a quantidade de um determinado símbolo dentro a cadeia

devemos nos referir a ocorrência. No exemplo 02, a ocorrência de ‘a’ em C1 é 2 e em C4
é 5.
2. Concatenação: ocorre quando construímos uma nova cadeia a partir de duas ou mais
cadeias, uma seguida da outra. É denotado por //, ou simplesmente o símbolo pode ser
omitido, ou seja, a // b = ab.
Exemplo 03: Exemplos de concatenação de cadeias:
C1 // C2 = aabbacb C4 // C3 = aaaccaabb C5 // C1 = ccaaaab
A concatenação é associativa, ou seja, não importará a sequência com que a concatenação

é feita, o resultado dará sempre o mesmo, mas não é comutativa, ou seja, a ordem das
cadeias influencia o resultado.
• Associatividade: (C1 // C2) // C3 = C1 // (C2 // C3).

• Não comutatividade: (C1 // C2) ≠ (C2 // C1)
8
3. Cadeia Reversa: Também chamada de Inversa, é a inversão dos elementos da cadeia,

onde o primeiro elemento passa a ser o último, o segundo o penúltimo e assim por diante
até o último se tornar o primeiro. Denotado por X.
Exemplo 04: Exemplos de cadeias reversas:
C1 = baa C2 = bcab C3 = b C4 = baaccaaa C5 = aacc
4. Elemento Neutro: Também camada de Cadeia Vazia, ou simplesmente ‘Vazio’, é a

cadeia válida formada pela ausência de caracteres e é denotado por λ ou por ε. Neste caso
temos que |λ| = 0, e C1 // λ = λ // C1 = C1. Por default, o λ está presente em todos os
alfabetos.
Atenção: cuidado para não confundir a cadeia vazia, com uma cadeia inválida, com o
conjunto vazio ou com a cadeia válida, não vazia, que possui apenas o caractere ‘espaço’
(ASCII = 32).
Atenção 2: a maioria dos autores denotam a cadeia vazia com o símbolo ε, diferente do
utilizado neste material.
5. Fecho: é o conjunto formado pelas cadeias geradas a partir da concatenação da cadeia

com ela mesma n vezes, onde n tende ao infinito. Também pode ser encontrado com o
nome de Concatenação Sucessiva. Existem dois tipos de fecho, que veremos a seguir:
5.1. Fecho Positivo: é a concatenação da cadeia n vezes, aonde n vai de 1 (um) até o
infinito e é denotado por x+.
Exemplo 05: Exemplos de fechos positivos no alfabeto {a, b}:
1) a+ = {a, aa, aaa, aaaa, aaaaa, aaaaaa, aaaaaaa, ...}

2) b+ = {b, bb, bbb, bbbb, bbbbb, bbbbbb, ...}
3) (ab)+ = {ab, abab, ababab, abababab, ababababab, ...}
4) a+b+ = {ab, aab, aaab, aaaab, abb, abbb, abbbb, aabb, aabbb, aabbbb, aaabb, ...}
5) a+b = {ab, aab, aaab, aaaab, aaaaab, aaaaaab, aaaaaaab, ...}
6) a+ba+ = {aba, aaba, abaa, aabaa, aaaba, abaaa, aaabaa, aabaaa, aaabaaa, ...}
Atenção: No exemplo 05.3, a cadeia ‘aba’, não faz parte do fecho por que não compõe a
concatenação da cadeia inteira com ela mesma inteira;
Atenção: No exemplo 05.6, o primeiro ‘a’ é totalmente independente do segundo ‘a’, cujos
mesmos variam livremente um do outro. O b é uma constante;
9
5.2. Fecho Estrela: também chamado de Estrela de Kleene, é semelhante ao fecho

positivo, porém permite a cadeia vazia dentro do conjunto formado (a cadeia pode existir
ou não.
Exemplo 06: Exemplos de fechos estrela no alfabeto {a, b}:
1) a* = {λ, a, aa, aaa, aaaa, aaaaa, aaaaaa, aaaaaaa, ...}

2) b* = {λ, b, bb, bbb, bbbb, bbbbb, bbbbbb, ...}
3) (ab)* = {λ, ab, abab, ababab, abababab, ababababab, ...}
4) a*b* = {λ, a, b, aa, bb, ab, aab, aaab, aaaab, abb, abbb, abbbb, aabb, ...}
5) a*b = {b, ab, aab, aaab, aaaab, aaaaab, aaaaaab, aaaaaaab, ...}
6) a*ba* = {b, ab, ba, aba, aaba, abaa, aabaa, aaaba, abaaa, aaabaa, aabaaa, aaabaaa, ...}
Observação: a* = a+ ∪ λ
2.2. LINGUAGENS (L)
Uma linguagem, denotada por L, é um meio de comunicação, formada por um conjunto de palavras
e de regras gramaticais que permitem combinar as palavras em sentenças sintaticamente corretas.
Uma linguagem é dita formal quando pode ser representada através de um sistema com sustentação
matemática, ou seja, uma linguagem é um conjunto de palavras qualquer, que possuem uma regra em
comum, com elementos pertencentes a um alfabeto.
Com este conceito, podemos afirmar que qualquer subconjunto de cadeias formadas a partir de um
alfabeto é uma linguagem, o próprio conjunto formado por todas as palavras do alfabeto também é
uma linguagem, além de existir a linguagem vazia, composta apenas pela cadeia vazia (λ).
Exemplo 07: Um exemplo de linguagem, dentro do alfabeto {a, b}, é a linguagem formada por todas
as palavras de tamanho igual a dois: L = {aa, ab, ba, bb}.
Exemplo 08: Linguagem de todas as cadeias iniciadas em ‘a’, dentro do alfabeto {a, b}: L = {a, ab,
aa, aba, abb, abbb, aaa, abbabab, aabba, ...}.
2.2.1. O PODER DAS LINGUAGENS

O poder de uma linguagem nada mais é do que a quantidade de cadeias que a mesma possui. No
exemplo 07, o poder da linguagem gerada é 04 (quatro), já no caso do exemplo 8, esse poder tende
ao infinito.
2.2.2. PROPRIEDADES DAS LINGUAGENS
Como uma linguagem é definida como sendo simplesmente um conjunto de palavras sobre símbolos
de um alfabeto, todas as operações sobre conjuntos podem ser aplicadas sobre linguagens. Em
particular, podem-se aplicar sobre linguagens as operações de união, intersecção, diferença e
complemento (Não). O significado destas operações sobre linguagens é bastante intuitivo.
10
1. União ( ): A união de duas linguagens L1 e L2 é linguagem L, que contém todas as palavras

que pertencem a qualquer uma das linguagens. Definido formalmente:
L = L1 L2 = {w ∈ Σ* / w ∈ L1 ou w ∈ L2 }
Exemplo 09: L1 = {a, ab, abb, abbb, abbbb, ...} e L2 = {b, ab, aab, aaab, aaaab, ...}
L = L1 L2 = {a, b, ab, abb, aab, abbb, aaab, aaaab, abbbb, ...}
2. Intersecção (∩): A intersecção de duas linguagens L1 e L2 é a linguagem L, que contém

todas as palavras que pertencem simultaneamente às duas linguagens. Definido formalmente
como:
L = L1 ∩ L2 = {w ∈ Σ* / w ∈ L1 e w ∈ L2}
Exemplo 10 (usando as linguagens do exemplo 09): L = L1 ∩ L2 = {ab}
Atenção: Caso não existisse nenhuma cadeia presente em ambas as linguagens, a intersecção
seria o conjunto vazio, denotado por O. Neste caso jamais a resposta poderia ser o vazio (λ),
pois o vazio não está presente em nenhuma as linguagens do exemplo.
3. Não (~): Também chamado de complemento. É uma linguagem que contém todas as cadeias
que não pertencem a L. Uma vez que Σ* é o conjunto de todas as palavras que podem ser
formadas sobre um alfabeto Σ, então o complemento da linguagem L, construída sobre Σ é a
linguagem Σ* ~ L, ou ainda, definido formalmente:
Σ*~L = {w ∈ Σ*/ w ∈ L}
Exemplo 11 (usando as linguagens do exemplo 09):
~L1 = {λ, b, bb, bbb, ba, baa, bab, aaba, ababa, ...}
4. Diferença: A diferença de duas linguagens L1 e L2 é a linguagem L, que contém todas as

palavras que pertencem à linguagem L1, mas não pertencem à linguagem L2. Definido
formalmente:
L = L1 – L2 = {w ∈ Σ* / w Є L1 e w ∈ L2 }
Exemplo 12 (usando o exemplo 09):

L = L1 – L2 = {a, abb, abbb, abbbb, abbbbb, ...}
11
2.3. EXPRESSÕES REGULARES
Um dos grandes propósitos das Linguagens Formais é conseguir representar de maneira finita, um
subconjunto de linguagens de um alfabeto. Para as linguagens finitas, a enumeração exaustiva de
todas as palavras resolve a questão, o grande desafio são as linguagens infinitas.
Essa representação finita deve ser formada por um conjunto de símbolos finitos, dentre eles os
símbolos do alfabeto da linguagem a ser representada. Como o conjunto de todas as palavras que
pertençam a um alfabeto é infinito podemos dizer que o conjunto de todas as possíveis linguagens
dentro de um alfabeto também é infinito. Por ser infinito, não é possível representar todas as
linguagens de um alfabeto com um número finito de símbolos, porém podemos encontrar
representações finitas para a maioria das linguagens ditas interessantes.
Existem vários modelos de representações propostos para descrever uma linguagem, alguns mais
poderosos (reconhecem mais linguagens) que outros. O modelo mais simples de ser utilizado é
chamado de Expressão. Uma expressão é a representação da linguagem através de símbolos
matemáticos. Quando a expressão é formada apenas pelos elementos do alfabeto, parênteses e
as propriedades da cadeia e da linguagem, dizemos que a expressão é Regular. Toda expressão
Regular representa uma linguagem pela interpretação de seus símbolos. Uma linguagem é dita
regular se existir alguma expressão regular que a defina. Toda linguagem regular pode ser descrita
por uma expressão regular que nada mais é do que um formalismo gerador, pois expressa como
construir (gerar) as palavras de uma linguagem.
Exemplo 13: Exemplos de Expressões Regulares no alfabeto {a, b}.
Expressão Regular Linguagem Gerada/Geradora
aa Contém somente a palavra ‘aa’

ba* Cadeias que iniciam por b, seguido de zero ou mais a’s
(a)* {λ, a, aa, aaa, ... }
a* b* {λ, a, b, aa, ab, bb, aaab, aaa, ... }
a* U (ab)+ {λ, aa, ab, aaaa, abab, ababab, ... }
(a (a U b)*) {a, aa, ab, aaa, aba, aab, ... }
(ab U aab U abb) – (ab) {aab, abb}
~ (a*) {b, bb, bbb, bbbb, ...}
a+ba* {ab, aba, aabaa, abaa, aaba, aaaba, aaab, ...}
Pergunta importante: Qual é a Expressão Regular que representa todas as possíveis cadeias do
alfabeto {a, b}?
Exemplo 14: Exemplos de Expressões Regulares no alfabeto {0, 1}.
Expressão Regular Linguagem Gerada/Geradora

1*01* Cadeias que possuem apenas um 0
(0U1)* Cadeias que possuem todas as strings binárias
aa(aUb)*bb Cadeias que começam com aa e terminam com bb
bb(aUb)*U(aUb)*bb Cadeias que começam ou terminam com bb
12
Não existe uma regra geral para construção de uma expressão regular a partir de uma linguagem,
apenas a prática leva a perfeição.
Atenção: em algumas literaturas, poderá ser encontrado o termo “Substring” que nada mais é
do que um pedaço de um string.
Exemplos de substrings do string: “abbabbbababaa”: “abbbababaa” (“abbabbbababaa”), “bbb”

(“abbabbbababaa”), “babaa” (“abbabbbababaa”), “ba” (“abbabbbababaa”), “babb”
(“abbabbbababaa”), “bbabbbab” (“abbabbbababaa”)
EXERCÍCIOS
Atenção: Este exercício não tem valor quantitativo (para a nota), serve apenas para desenvolver o
aprendizado e ganhar experiência para as avaliações.
Construa linguagens regulares que reconheçam as sequências abaixo (Considere Σ = {0, 1}):
1. Terminadas em 00 00 01 e iniciadas por 11;

2. Terminadas por 00, mas que tenham, ao menos um 1;
3. Iniciadas por x;
4. Que não terminem em 10 e possuam, ao menos, dois elementos;
5. Que não iniciem com 00 e terminem com 1;
6. Que aceite somente {0,1,01,10};
7. Iniciados por 0 e que aceite 1 00 00 00;
8. Que possuam apenas uma dupla de zeros;
9. Que não possua zeros;
10. Que tenha 000 e 111;
11. Um número par de zeros;
12. Um número ímpar de zeros;
13. Não têm nenhum “1”;

14. São diferentes de “1”;
15. Contêm pelo menos algum “0” e algum “1”;
16. Têm comprimento não inferior a 2;
17. Não contêm “101” como cadeia válida;
18. Terminam em “1” mas não em “111”;
19. Têm pelo menos dois “0” consecutivos;
20. Terminam em “1” e têm pelo menos dois “0” consecutivos;
21. Têm um número ímpar de “0” ou um número par de “1”;
22. Têm no máximo um par de “0” e um par de “1” consecutivos;
23. São representação binária de inteiros positivos múltiplos de 4;
24. São representação binária de inteiros positivos múltiplos de 2 mas não de 3;
25. Contêm (algures) pelo menos três “0” seguidos, mas não contêm dois ou mais “1” seguidos;
26. Se têm algum par de “0” adjacentes, este aparece antes de qualquer par de “1” adjacentes;
27. Não terminam em “1101” nem em “1011”;
28. Têm igual número de “0” e “1” e nenhum seu prefixo tem um número de “0” que excede em
dois o número de “1”, nem um número de “1” que excede em dois o número de “0”
13
APOSTILA DE LINGUAGENS FORMAIS – AUTÔMATOS FINITOS Prof. TENORIO
3. AUTÔMATOS FINITOS
Como já foi dito, existem vários modelos de representações propostos para descrever uma linguagem,
alguns mais poderosos (reconhecem mais linguagens) que outros. Alguns modelos, além de
linguagens, são capazes de representar todo um sistema. Imaginem uma agenda eletrônica. Agora, na
posição de analistas de sistemas, vamos apresentar aos programadores essa mesma agenda de duas
formas diferentes.
Forma 01: O sistema consiste em uma agência eletrônica com uma tela principal, e as opções de
Inserir, Alterar, Remover, Buscar e Sair. Ao teclar 01 o usuário vai para a tela de inserção que pede
um nome e depois a tecla ‘Enter’. Na tela seguinte pedirá o telefone e novamente a tecla ‘Enter’,
retornando ao menu principal. Teclando 2 no menu principal, o sistema irá para a tela de Alterar.
Nesta tela será pedido o nome de uma pessoa e a tecla ‘Enter’. Na tela seguinte o telefone desta pessoa
e novamente a tecla ‘Enter’. Por fim, uma mensagem de “Atualizada com sucesso! Tecle Enter.”,
após pressionar a tecla ‘Enter’, o sistema retorna ao menu principal. Teclando 3 no menu principal, o
sistema irá para a tela de remover. Nela será solicitado um nome. Caso esse nome esteja cadastrado,
vai aparecer a mensagem: “Removido com sucesso”. Caso o nome não esteja cadastrado, aparece a
mensagem “Nome não existe, tecle Enter” e teclando Enter, o sistema retorna ao menu principal.
Teclando 4 no menu principal, o sistema irá para a tela de buscar. Esta tela ira pedir o nome da pessoa
que se quer buscar. Caso o nome exista, irá aparecer em tela seguinte o nome e o telefone da pessoa
cadastrada. Caso não exista, aparece a mensagem “Nome não existe. Tecle Enter”. Retornando ao
menu principal. Teclando 5 no menu principal, o sistema vai para a tela de confirmação de saída, com
a mensagem: “Tem certeza que deseja sair [s/n]?”. Caso o usuário tecle ‘S’, o programa será
encerrado, caso tecle ‘N’, o sistema retorna ao menu principal. Também existe a opção de que se tiver
transcorrido muito tempo sem que o usuário tecle algo o sistema irá para uma proteção de tela que só
será liberada quando o usuário teclar “Enter”.
Forma 02:
14
Qual das duas formas é mais legível, ou seja, é mais fácil de entender? Claro que é o diagrama, pois
o texto é chato e deixa margem para ambiguidades e interpretações diferentes. Isso não acontece no
diagrama. A esse diagrama damos o nome de Diagrama de Estados, esse é o nome mais utilizado,
porém, seu nome formal é Autômato Finito. E é a construção desse diagrama que iremos aprender
daqui para frente.
Um autômato finito pode ser considerado um modelo matemático (máquina abstrata) de um sistema,
com entradas e saídas discretas. O sistema pode estar em um de vários, porém finitos, estados
(configurações internas). O estado de um sistema resume as informações anteriores, até o momento
atual do reconhecimento, necessárias para determinar o seu comportamento face ao resto da sequência
que está analisando. Um bom exemplo de um autômato finito é o mecanismo de controle de um
elevador. Ele não lembra todas as requisições anteriores mas somente o andar atual, a direção de
movimento (para cima ou para baixo), e a relação de requisições pendentes. Uma máquina de estados
finitos ou Autômato Finito é uma modelagem restrita de um comportamento, composto por estados
e transições.
Estado: É a descrição do sistema em um determinado instante.
Transição: É uma mudança de Estado.
Um estado reflete a posição do sistema em um determinado instante. É como se fosse uma fotografia
do sistema que o mostra naquele exato momento em que a ‘fotografia’ foi tirada e uma transição
indica uma mudança de estado e é descrita por uma única1 condição que precisa ser realizada para
que a transição ocorra. Existem três tipos de transições:
1. De usuário: provocada por uma ação do usuário;

2. Espontâneas: provocada por uma ação mecânica, do sistema;
3. Instantâneas: provocada apenas uma vez e acontece na inicialização do sistema;
Essa máquina de estados recebe uma entrada de dados, porém não gera nenhuma saída em seu
processamento, exceto a indicação informando se a entrada é ou não aceitável naquela máquina. O
que torna o Autômato Finito restrito é a falta de memória externa, que possa ser expandida ou utilizada
para gravar dados, assim como a memória RAM encontrada nos computadores atuais.
3.1. CONCEITO
O conceito de Autômato Finito, formalmente falando, é uma quíntupla, formada por:
1
Única, neste caso, significa que cada transição só possui um único elemento do alfabeto em questão.
15
Para facilitar o estudo e a construção dos autômatos, não serão utilizados exemplos de sistemas reais,
como a agenda apresentada no início deste capítulo, serão feitos diagramas genéricos que servem para
quaisquer situações, pois nosso objetivo é aprender a montar o diagrama e não sua aplicabilidade, que
será vista em outra disciplina. Para tanto vamos conhecer algumas convenções adotadas pelos mais
diversos autores para a construção de autômatos.
Vale lembrar que o autômato é a quíntupla e não o diagrama. O diagrama é uma mera representação
gráfica do que pode ser o autômato.
O principal objetivo dos autômatos é a validação de cadeias. Para uma cadeia ser válida, ela precisa
fazer transições que iniciem no estado inicial do autômato e terminem em algum estado final do
mesmo. Caso a cadeia termine em um estado dito não-final, a cadeia é considerada inválida.
Formalmente falando, as cadeias são escritas em uma fita (vetor de caracteres) e esta fita tem seus
caracteres lidos um a um terminado após a leitura do último caractere. Ao terminar, se a posição atual
for um estado final, a cadeia é dita válida.
3.2. CONVENÇÕES
As convenções usadas neste material, são usadas por muitos autores, mas não por todos, portanto, em
algumas literaturas, símbolos diferentes podem ser encontrados, sem que isto altere o conceito dos
mesmos.
1) O nome dos estados será sempre a letra q, e serão diferenciados por um índice.
Exemplo: q0, q1, q2, q3, q4, q5, q6, q7, q8, q9 ,q10, ..., qN
2) q0 será sempre o estado inicial;
3) Os estados serão representados por um círculo, com seu nome no interior.

Exemplo:
4) As transições serão representadas por uma seta com um único elemento do alfabeto rotulando-
a. Exemplo:
a
5) O estado inicial será demarcado com uma seta que vem do ‘nada’ e apontando para o mesmo.
Exemplo:
q
16
6) Os estados finais serão demarcados com um círculo em seu interior.

Exemplo:
7) Duas transições diferentes, partindo de uma mesma origem e chegando a um mesmo destino,
poderão ser representados, com uma seta única, e seus nomes serão separados por vírgula.
Exemplo:
a a, b
q b q equivale a: q q
3.3. DETERMINISMO
O autômato finito é dito Determinístico se, e somente se, para cada elemento do alfabeto exista
uma, e apenas uma transição de saída, de cada estado pertencente ao autômato, ou seja, um
mesmo elemento do alfabeto não pode ter duas ou mais transições de saída de um mesmo estado e
obrigatoriamente, deve ter uma saída do mesmo. Isto significa que, estando o processamento em um
estado qualquer, e obtendo um valor qualquer do alfabeto como entrada, sempre existirá um único
caminho a percorrer dentro do autômato.
O autômato que não seguir esta regra é denominado de Autômato Finito Não Determinístico. Uma
entrada será válida em um autômato finito não determinístico se houver pelo menos uma sequência
correta de passos que leve o processamento a um estado final.
O autômato finito determinístico possui apenas transições de usuário e a transição instantânea, não
possuindo transições espontâneas (vazias).
3.4. AUTÔMATO FINITO DETERMINÍSTICO
Para melhor representar um autômato, utilizaremos a forma mais conveniente chamada de Diagrama
de Estados. É um grafo dirigido (dígrafo) onde os vértices são os estados e as arestas são as transições.
Sempre lembrando que o autômato é a quíntupla e não o diagrama, sendo este apenas uma
representação gráfica do autômato.
Existem duas formas de se construir um autômato finito determinístico:
1 – A Regra da Cadeia Mínima, que veremos a seguir;

2 – A Regra da Transformação, que veremos mais adiante;
Nem sempre é possível escrever um autômato pela regra da cadeia mínima, nestes casos, deve-se
utilizar obrigatoriamente a regra da transformação que serve para qualquer linguagem regular.
Vale lembrar que não importa a regra que se use para criar um autômato, o que devemos ter em mente
é que sempre uma cadeia válida deve começar no estado inicial e parar em um estado final e uma
cadeia inválida NÃO pode começar em um estado inicial e chegar em um estado final
17
3.5. REGRA DA CADEIA MÍNIMA
Nesta regra deve-se seguir rigorosamente os seguintes passos:
• Passo 1 – Verificar se os elementos que compõem a linguagem (vamos nos referir a expressão
regular que representa a linguagem, como a própria linguagem) fazem parte do alfabeto;
• Passo 2 – Isolar a chamada “Cadeia Mínima”. A cadeia mínima será formada pelos elementos
do alfabeto, que aparecem na linguagem, na mesma ordem em que aparecem, excluindo-se as
propriedades e os elementos dentro da Estrela de Kleene (Fecho Estrela);
• Passo 3 – Escrever uma sequência do estado inicial a um estado final, com a cadeia mínima,
utilizando-se das convenções, lembrando que cada transição só poderá conter um único
elemento do alfabeto. A essa sequência daremos o nome de “Esqueleto”;
• Passo 4 – Tornar o autômato determinístico, ou seja, incluir as saídas não criadas pelo item
anterior. Essas saídas devem corresponder aos elementos das propriedades presentes na
linguagem (excluídas no passo 02);
Caso não se tenha encontrado o destino de alguma saída pelo passo 4, esta saída deve ser direcionada
para um estado chamado de Estado Morto. Este estado nunca será um estado final e suas saídas
sempre retornarão para si mesmo. Este estado será representado no diagrama da seguinte forma:
M Σ
EXEMPLO 3.01: No Σ = {0,1}, construir um Autômato Finito Determinístico para a linguagem:
L = 10+
• Passo 01: Os elementos da linguagem 10+ fazem parte do Σ = {0,1}?
Neste caso sim, pois a linguagem é composta apenas de elementos do alfabeto e de propriedades, no
caso, ao propriedade do fecho positivo.
Esta linguagem é formada pelas seguintes cadeias: {10, 100, 1000, 10000, 100000, 1000000, ...}
• Passo 2: A cadeia mínima será ‘10’, ou seja, é a expressão da linguagem apresentada sem as
propriedades e sem os elementos que estão na Estrela de Kleene (Neste exemplo não existe
nenhum elemento na Estrela de Kleene – Fecho Estrela).
• Passo 3: Construir o Esqueleto com a cadeia mínima ‘10’. Assim temos:
18
• Passo 4: Adicionando as propriedades da cadeia presentes na linguagem e o estado morto

temos:
Agora sim terminamos o nosso primeiro autômato finito determinístico.
EXEMPLO 3.02: Construir um AFD para a linguagem: L = 1+001* no Σ = {0,1}
• Passo 01: Os elementos da linguagem 1+001* fazem parte do Σ = {0,1}?
Neste caso sim, pois a linguagem é composta apenas de elementos do alfabeto e de propriedades.
Esta linguagem é formada pelas seguintes cadeias: {100, 1100, 1001, 10011, 11001, 110011, ...}
Atenção: o elemento 1+ não depende do 1* em termos de quantidade.
• Passo 2: A cadeia mínima será ‘100’, ou seja, é a linguagem sem as propriedades e sem os
elementos que estão na Estrela de Kleene (Neste exemplo o elemento 1* foi omitido da cadeia
mínima por estar na Estrela de Kleene – Fecho Estrela);
• Passo 3: Com a cadeia mínima ‘100’ temos:
• Passo 4: Adicionando as propriedades da cadeia presentes na linguagem e o Estado Morto

temos:
Neste exemplo verificamos a simplificação do Estado Morto com a 7ª convenção. Agora é hora do
aluno fazer o teste de validação das cadeias encontradas no passo 1.
Fazer o teste de validação é fundamental para o aprendizado. Validar uma cadeia significa testá-la,
ou seja, verificar se, iniciando no estado inicial, ela realmente para em um dos estados finais do
diagrama.
19
3.5.1. LEMAS DA REGRA DA CADEIA MÍNIMA
Na regra da cadeia mínima, alguns detalhes devem ser observados. Esses detalhes visam auxiliar o
aluno na construção dos autômatos, impedindo que cadeias inválidas cheguem ao estado final e
permitindo que cadeias válidas sempre cheguem ao estado final. São lemas na construção do autômato
que devem sempre ser respeitados. Estes lemas serão mostrados a partir de exemplos sempre no Σ =
{0,1, 2}
Nos exemplos deste tópico, o estado morto foi omitido a fim de simplificar os desenhos. Lembre-se
sempre da regra do determinismo.
Lema 01: Fecho Positivo com um único elemento. O fecho positivo com um único elemento é
geralmente formado por um loop no estado em que seu elemento obrigatório o aponta.
Exemplo: L = 21+2. Neste exemplo o 1 do positivo aponta para o q2, assim o loop ficará no q2
Lema 02: Fecho Estrela (Estrela de Kleene) com um único elemento. O fecho estrela com um
único elemento é geralmente formado por um loop simples na sua devida posição. A posição é dada
pelo antecessor e pelo sucessor na linguagem. Neste caso NÃO se deve criar estados.
Exemplo: L = 21*2. Neste exemplo o loop do 1 ficará no q1
Lema 03: Fecho Positivo com dois ou mais elementos. O fecho positivo com dois ou mais
elementos é representado apenas por um retorno (seta voltando), saindo do último estado pertencente
ao fecho e apontoando para o segundo. O elemento do alfabeto desta transição é o elemento inicial
do fecho. Vale lembrar que as transições que representam um mesmo elemento devem apontar sempre
para o mesmo lugar
Exemplo: L = 2(021)+2. Neste exemplo o fecho positivo engloba os elementos 0 2 e 1. No diagrama

esses elementos formam uma sequência que inicia no q1 e termina no q4, portanto, para resolver este
lema, basta colocar uma saída do q4 (último estado do fecho) apontando para o q2 (segundo estado
do fecho) com o elemento 0 (que consiste no primeiro elemento pertencente ao fecho – 021)
20
Lema 04: Fecho Estrela com dois ou mais elementos. O fecho estrela com dois ou mais
elementos é representado com a criação de x novos estados, onde x é a quantidade de elementos
constantes/positivos que se encontram dentro do fecho menos um. Esses novos estados fecharão um
loop no estado onde se encontra o fecho na linguagem (antecessor e sucessor).
Exemplo: L = 2(001)*2. Neste exemplo, temos 3 elementos constantes/positivos dentro do fecho

estrela, portanto dois novos estados serão criados (3 – 1). O antecessor do fecho é o elemento 2 e o
sucessor é o segundo elemento 2. No diagrama, o estado q1 é o estado que tem esses elementos como
antecessor e sucessor respectivamente, portanto ele será o início e o fim do loop criado com os novos
estados gerados pelo lema.
Lema 05: Loops Sucessivos. Este lema é usado quando, na linguagem, existem dois ou mais
fechos estrelas seguidos (consecutivos), caracterizando elementos diferentes que precisam de loop.
Neste caso, apenas o primeiro elemento recebe um loop simples (seguindo o lema 2), para os demais
fechos estrelas é criado um novo estado para suprir a necessidade do loop. Um estado para cara fecho.
Exemplo: L = 20*1*2. Neste caso, será criado um estado para o 1* e NÃO será criado estado para o
0*, que seguirá normalmente pelo lema 2.
Errado Certo
21
Lema 06: Regra obriga duas saídas. Quando os lemas anteriores são aplicadas corretamente e
um loop gera duas ou mais saídas iguais, o loop causador do não-determinismo deve seguir para o
próximo estado.
Exemplo: L = 21+12. Neste exemplo, seguindo corretamente o lema 1, conforme o diagrama, é gerado
duas saídas 1 para o estado q2. Uma saída apontando para o estado q3 e outra formando um loop
apontando para o próprio q2. O lema 6 pede para o loop ser transferido para o estado seguinte (neste
caso o q3). Caso a mesma coisa ocorresse no q3, ou seja, se ele já tivesse uma saída 1, basta aplicar
novamente o lema 6, fazendo o loop seguir em frente.
Errado
Certo
Lema 07: Cadeia mínima é vazia. Quando a cadeia mínima é vazia, por conta de um fecho estrela
que engloba toda a linguagem, o estado inicial q0, torna-se um dos estados finais, transformando o
fecho estrela em positivo. Depois disso, resolve a questão aplicando os demais lemas estudados.
Exemplo: L = (2012)*. Neste exemplo, o q0 tornou-se final e a linguagem passou a ser: L = (2012)+
Atenção: o retorno do loop estrela (transição 2 do q4) jamais deve retornar ao q0, pois permitiria que
uma cadeia inválida chegasse ao estado final – ex: 201222012. Lembre-se que as transições que
representam um mesmo elemento devem apontar sempre para o mesmo lugar. Neste exemplo, as
transições 2 do q0 e do q4 representam o mesmo elemento na linguagem, por isso, devem apontar
para o mesmo estado.
Lema 08: Não. Quando a linguagem vier com um “não”, basta simplesmente inverter o tipo dos
estados do diagrama, ou seja, se o estado não for final ele passará a ser, inclusive o estado Morto e se
caso ele já seja final, passará a ser uma estado não final.
22
Exemplo: ~ (001)
Sem o ~ (não)
Com o ~ (não)
Lema 09: União. Na união, cada lado deve começar no estado inicial, porém, os estados que
fazem parte de um lado da união, NÃO podem, de forma nenhuma, estarem ligados aos estados que
pertencem a um outro lado da união.
Exemplo: 0*21 U 110*. Neste exemplo, o loop do elemento 0* do primeiro lado da união, não poderá
ficar no estado q0, pois isso permitiria que cadeias, iniciadas em 0*, pudessem terminar com 110*,
validando cadeias como 000011, que são inválidas na linguagem, ou seja, colocando o loop 0* no q0,
como saber a qual lado ele pertence apenas olhando para o desenho? No autômato, não pode haver
ambiguidades.
É importante salientar que estados compartilhados pelos lados da união (como o q0 neste exemplo)
não poderão participar de nenhum loop ou ciclo, pois, desta forma, não teremos controle de qual lado
da união o loop ou ciclo pertence.
Errado Certo
Muitas vezes, não é apenas o q0 que será compartilhado entre os lados da união. Vários estados poder
ser compartilhados por lados diferentes de uma união, isto significa que nenhum deles pode estar
23
contido em um ciclo, nem receber transições fora a transição do esqueleto. Caso seja necessário
a criação destes ciclos, novos estados, que representam os compartilhados, devem ser criados. Estes
novos estados serão exclusivos de um lado da união, mas representação os estados compartilhados.
Exemplo: (12012)+ U 12*10. Neste exemplo, ambos os lados da união iniciam em 1 e logo após o 1
tem um elemento 2 obrigatório do primeiro lado e estrela no segundo lado, isso obrigará a criação de
novos estados. Como os dois primeiros elementos podem ser iguais, temos três estados
compartilhados entre os lados da união, o q0, o q1 e o q2. Estes estados não podem receber setas
exceto as setas do esqueleto. O q1 é o estado que divide as cadeias mínimas dos lados da união,
seguindo 2 para o q2 (primeiro lado da união) e 1 para q6 (segundo lado da união). O segundo lado
da união traz um fecho estrela do elemento 2, que, conforme o lema 2 deveria ficar no q1, como o q1
é compartilhado (portanto não pode receber setas que não sejam do esqueleto) foi criado o q8 para
receber o loop. Além disso, foram criadas as possibilidades para este q8 receber o loop (transições 1
e 2 saindo do q2).
Em relação ao fecho positivo do primeiro lado da união, segundo o lema 3, uma transição 1 deveria
sair do q5 e retornar ao q1, porém, o q1 é um estado compartilhado, portanto, não pode receber setas
além da seta do esqueleto (o que fecharia um ciclo). Para resolver este problema foi criado o q9, que
na verdade é uma “cópia” do q1, porém, exclusivo do primeiro lado da união, podendo este receber
a transição 1. Como o q9 é “cópia” do q1, ele também precisa da transição 2 para o q2, porém, o q2
também é compartilhado e pelo mesmo motivo não pode receber transições fora do esqueleto. Para
resolver este problema foi criado o q10 para “copiar” o q2 e receber a transição 2. Saindo do q10 deve
ter uma transição 0 para o q3, como o q3 não é compartilhado e só pertente ao primeiro lado da união,
ele recebe a transição 0 sem nenhum problema. Caso o q3 fosse compartilhado, seria criado um q11
para substituí-lo e a sua transição iria para o q4.
Atenção: Estes lemas não funcionam para qualquer linguagem, mas são eficientes para um grande
número delas. Só é preciso ter em mente que nenhuma cadeia inválida deve terminar em um dos
estados finais e nenhuma cadeia válida deve terminar em um estado dito não-final.
Pra garantir isso, a melhor maneira é testar diversas cadeias válidas e inválidas.
24
3.6. REGRA DA TRANSFORMAÇÃO
Como já foi dito, a regra da cadeia mínima não funciona para todas as linguagens/expressões
regulares. Para as linguagens que a cadeia mínima não resolve, opta-se pela regra da transformação.
A regra da transformação funciona para qualquer expressão regular/linguagem regular e consiste em
duas etapas principais:
1 – Criar o autômato finito Não-Determinístico;

2 – Transformar esse autômato não-determinístico em determinístico, usando o algoritmo de
transformação.
3.6.1. AUTÔMATO FINITO NÃO-DETERMINÍSTICO
Um autômato finito não-determinístico possui as mesmas características de um autômato finito

determinístico, porém o próximo estado não é necessariamente unicamente determinado pelo estado
atual e pelo Σ. O autômato finito não-determinístico permite que se tenha uma ou mais transições de
estado com o mesmo elemento do Σ, além de permitir transições vazias (λ), ou seja, permite que se
mude de estado sem nenhuma leitura de elementos do Σ. Os autômatos finito não-determinísticos que
possuem transições vazias são chamados de autômato finito não-determinístico-lambda.
A forma de construção de um autômato finito não-determinístico é similar a construção de um

autômato finito determinístico pela regra da cadeia mínima, porém não se precisa seguir a regra do
determinismo, nem colocar estado Morto.
É sempre bom lembrar que não só existe uma única forma de se fazer um autômato finito. Vários
autômatos, feitos de maneiras diferentes, podem chegar a uma mesma linguagem, o que vale sempre
é que uma cadeia válida precisa terminar em um dos estados finais e uma cadeia inválida não pode
terminar em um desses estados finais.
Uma cadeia/entrada será válida em um autômato finito não determinístico se houver pelo menos uma
sequência correta de passos que leve o processamento a um estado final. Isso por que, como os estados
podem ter duas ou mais saídas iguais levando a caminhos diferentes, uma cadeia válida pode, por um
caminho chegar no estado final, mas em outro caminho, não chegar. Para ser válida, basta que exista
um caminho até o estado final. A única forma de saber é percorrer todos os caminhos possíveis com
a cadeia, a partir do inicial, e verificar se pelo menos um deles chega ao estado final.
Exemplo 01: (00 (0*1*2*)* 210*)*
As linguagens que contenham, em algum momento, a expressão que reconhece todas as cadeias, deve
ser feita pela regra da transformação. Sua versão não-determinística é feita apenas colocando os loops
no estado correspondente.
25
Exemplo 02: L = 10*1*0*2*0
Exemplo 03: L = (0*111+10)* U 10*01
3.6.2. ALGORITMO DE TRANSFORMAÇÃO
Apesar de aparente força e generalidade do autômato finito Não-Determinístico, eles não são mais
poderosos que os determinísticos, ou seja, para cada autômato finito Não-Determinístico, há um
autômato finito Determinístico equivalente.
Formalmente, dizemos que os dois autômatos são equivalentes entre si, pois não há nenhuma
linguagem que possa ser representada por um autômato finito Não-Determinístico, que não possa ser
representada por um autômato finito determinístico.
26
O algoritmo de transformação de um autômato não-determinístico em determinístico compõe a regra

de criação dos autômatos finitos que não podem ser feitos pela regra da “Cadeia Mínima” e consiste
em quatro etapas.
1 – A primeira diz respeito à criação do conjunto de cada estado que é formado pelo próprio estado e
todos os estados alcançáveis (possuem caminho) com a leitura de elementos vazios (λ), inclusive
sequenciados;
2 – A segunda etapa diz respeito à identificação do estado inicial do autômato determinístico a que
se quer chegar. O estado inicial do AFD é formado pelo conjunto do estado inicial do AFND;
3 – A terceira etapa especifica o destino correto de uma única saída para cada elemento do alfabeto,
em função recursiva, partindo das possíveis saídas do estado inicial encontradas na etapa anterior.
Deve-se perguntar para qual estado irá cada um dos elementos do alfabeto envolvido e criar o estado
caso ele não exista. Essa operação deve ser repetida até que o autômato já esteja seguindo a regra do
determinismo;
Atenção: Nesta etapa devemos ter em mente que os estados do AFD são os conjuntos dos estados do
AFND e não simplesmente os estados do AFND.
4 – A última etapa trata da detecção dos estados finais. Os estados finais do AFD serão todos aqueles
que possuem, em seu conjunto, algum estado final do AFND.
Para um melhor entendimento, vamos a um exemplo.
Transformar o AFND abaixo em AFD no Σ = {0, 1}.
Resposta:
• Etapa 01: Criar o conjunto de cada estado.

q0 = {q0, q1} q1 = {q1} q2 = {q2}
q3 = {q3, q4, q5} q4 = {q4, q5} q5 = {q5}
• Etapa 02: Identificação do estado inicial. No exemplo, o q0 do AFD será formado pelos
estados q0 e q1, que compõe o conjunto do q0 do AFND.
• Etapa 03: Verificar os destinos para os elementos 0 e 1 a partir do estado inicial. O AFD
poderá ter até 2N estados, onde N é a quantidade de estados do AFND.
27
• Etapa 04: Demarcar os estados finais. No exemplo, todos os estados que possuem o q4 serão
finais, pois o q4 é final no AFND.
•
3.7. MINIMIZAÇÃO DE AUTÔMATOS
Em muitos casos, um autômato finito, seja ele determinístico ou não, pode ser escrito de maneira mais
simples, com menos estados, sem que seja alterada a linguagem reconhecida por este autômato. Esse
é o processo conhecido como minimização de estados. É um processo bastante simples, baseado
apenas em apenas duas fases.
A primeira fase diz respeito à eliminação de estados inalcançáveis. Um estado é dito inalcançável
se, e somente se, partindo do estado inicial não haja nenhuma possibilidade de entrada no autômato
28
que leve a este estado, ou seja, se o autômato não pode utilizar um determinado estado, então esse
estado pode ser removido sem nenhum prejuízo à linguagem reconhecida por ele.
A segunda fase diz respeito à função de cada estado. Quando dois ou mais estados possuem a
mesma função, é possível fazer a fusão deles em um estado único. Dizemos que dois ou mais
estados possuem a mesma função quando, a partir de qualquer um deles, as mesmas entradas
conduzem o autômato a uma situação única, de aceitação ou rejeição. Para comprovar
matematicamente que dois ou mais estados possuem a mesma função, deve-se seguir os seguintes
passos:
1 – Construir a pirâmide (matriz) de marcação, que nada mais é do que uma matriz triangular, sem a
diagonal principal, que confronta um a um todos os estados do autômato. Nela, os estados são
dispostos de cima para baixo e da esquerda para a direita. Deve-se tentar verificar, na matriz, com os
passos seguintes, a possibilidade de um par qualquer de estados serem iguais. Caso seja provado que
um par de estados é diferente entre si, sua posição na pirâmide será marcada, caso não se garanta a
diferença, a posição não será marcada. No final, os estados não marcados na pirâmide serão
colapsados em um estado único entre si e os demais (marcados) ficaram isolados no novo autômato;
2 – Marcar estados finais com os estados não-finais. Pela simples função de aceitação e rejeição, os
estados finais são diferentes dos estados não-finais e por isso precisam ser marcados na pirâmide;
3 – Devem ser marcados na pirâmide também, os estados cujos destinos com a leitura de qualquer
um dos elementos do alfabeto sejam diferentes, ou seja, um elemento qualquer do alfabeto deve
encaminhar os estados para uma mesma posição, só assim, poderemos garantir que esses estados são
iguais;
Para um melhor entendimento, vamos a um exemplo:

Gerar o autômato mínimo, ou seja, minimizar o autômato finito a seguir, no Σ = {0, 1}.
29
Primeira fase: eliminar os estados inalcançáveis. Com essa eliminação o autômato fica assim:
Segunda fase: colapsar os estados equivalentes.
Resposta Final – Autômato Mínimo
Atenção: No resultado da minimização não pode haver, de forma alguma, inclusão de outros estados
que não sejam os estados presentes na pirâmide de marcação, inclusive estado morto. Isto quer dizer
que o resultado da minimização pode ou não ser determinístico.
30
3.8. LINGUAGENS NÃO-REGULARES
Como já vimos, o poder os autômatos finitos são restritos as linguagens regulares. Uma linguagem é
regular se e somente se, em processando qualquer cadeia, a informação a ser armazenada em qualquer
estágio é estritamente limitada àquele estágio, ou seja, a leitura de qualquer símbolo de uma cadeia é
totalmente independente da leitura dos demais símbolos da cadeia.
Em algumas linguagens, essa independência não acontece, ou seja, é necessário armazenar

informações de leituras anteriores para possibilitar a leitura de caracteres seguintes. Vejamos o
exemplo.
Atenção: Um caractere X elevado a um expoente N significa uma cadeia formada de N vezes o

caractere X. Ex.: 05 = 00000, 17 = 1111111, (10)3 = 101010, 1N / N ≥ 3 = {111, 1111, 11111, ...}
Na linguagem L = 0N1N / N ≥ 1, temos as seguintes cadeias válidas:

C = {01, 0011, 000111, 00001111, 0000011111, 000000111111, 00000001111111, ...}
Neste exemplo, para que possa saber a quantidade de caracteres 1’s a serem lidos é necessário
armazenar a quantidade de elementos 0’s lidos, pois a linguagem pede que a quantidade de uns seja
exatamente igual a quantidade de zeros.
Como o autômato finito não possui nenhuma estrutura de memória, não há como guardar este valor,
ou seja, não há como saber a quantidade de zeros lidos, impossibilitando assim a leitura correta da
quantidade de uns.
Assim, chegamos à conclusão que as linguagens não-regulares precisam de uma estrutura de memória
para poderem ser representadas formalmente e como o autômato finito não possui nenhuma estrutura
de memória, seu poder não abrange as linguagens não-regulares.
31
APOSTILA DE LINGUAGENS FORMAIS – GRAMÁTICAS Prof. TENORIO
4. GRAMÁTICAS
A Gramática é uma linguagem formal que serve para definir qual o subconjunto de sentenças que faz
parte de uma determinada linguagem. Especifica linguagens potencialmente infinitas de uma forma
finita. Seu poder é superior ao poder dos autômatos finitos, pois abrange as Linguagens Regulares e
Linguagens Não-Regulares.
A principal aplicação das gramáticas é a construção e descrição de interpretadores e compiladores.
1. CONCEITO
Formalmente falando, uma Gramática é uma quádrupla, formada por:
• V: Conjunto de Variáveis;
• ∑: Alfabeto;
• S0: Produção Inicial. S0 ∈ V. Por convenção usaremos S como S0;
• δ: Função de Produção.
2. CLASSES DE GRAMÁTICAS
Conforme as restrições impostas ao formato das produções de uma gramática, a classe de linguagens
que tal gramática gera varia correspondentemente. Segundo Chomsky (Avram Noam Chomsky –
Filadélfia, 7 de dezembro de 1928 – professor Cátedra do MIT), as Gramáticas são organizadas em
quatro grandes classes, sendo que cada classe de gramática é capaz de gerar uma classe
correspondente de linguagens. Essa teoria é denominada Hierarquia de Chomsky (1959).
A Hierarquia de Chomsky organiza as classes das Gramáticas mediante o seu poder. Uma classe
superior engloba todas as classes inferiores e mais um conjunto de gramáticas próprias. As quatro
classes de gramáticas definidas por Chomsky são:
1 – Gramáticas com Estrutura de Frase;

2 – Gramáticas Sensíveis ao Contexto;
3 – Gramáticas Livres de Contexto;
4 – Gramáticas Regulares;
Graficamente, a hierarquia de Chomsky é mostrada na figura a seguir.
G. com Estrutura de Frase
G. Sensíveis ao Contexto
G. Livres de Contexto
G. Regulares
32
3. GRAMÁTICAS COM ESTRUTURA DE FRASE
As Gramáticas com Estrutura de Frase, também chamadas de Gramáticas Irrestritas ou TIPO 0, são
aquelas às quais nenhuma limitação em sua construção é imposta. São capazes de reconhecer
quaisquer linguagens recursivamente enumeráveis (uma linguagem formal é dita recursivamente
enumerável se ela é computável, ou seja, se existe um algoritmo que reconhece esta linguagem mas
que não necessariamente para qualquer entrada).
O universo das linguagens que se podem definir através dos mecanismos gerativos definidos pela
gramática corresponde exatamente ao conjunto das linguagens que esta classe de gramática é capaz
de gerar.
Formalmente falando, toda gramática é Estrutura de Frase se, e somente se:
∀ α ∈V & β ∈ Σ (α U β)+ = (α∗β∗)∗
Construção de uma Gramática
Para se construir uma gramática qualquer basta listar sua quádrupla. Vejamos um exemplo de
gramática para a linguagem L = 0N1N / N ≥ 1.
1 – Variáveis: Ainda não sabemos como calcular a quantidade de variáveis que a linguagem irá
precisar, por isso vamos declarar apenas uma e caso seja necessário declararemos mais. Por
convenção a primeira variável será sempre S, portanto, vamos declarar apenas o S.
V = S;
2 – Alfabeto: Como já sabemos, o alfabeto são os caracteres presentes na linguagem, neste caso,
apenas 0 e 1;
Σ = 0, 1;
3 – Produção Inicial: Por convenção será sempre S, a primeira variável declarada na gramática.
S0 = S;
4 – Função de Produção: A função de produção é o mecanismo gerador de todas as cadeias válidas

da linguagem e é composto de duas partes. A parte “Replicação”, onde se localiza a recursão geradora
que vai até o infinito e a parte “Obrigatória”, que é a saída da recursão e é composto pela “cadeia
mínima” da estrutura que a variável representa e a próxima variável, caso exista.
Importante: No posicionamento das variáveis nas produções da gramática, a variável da replicação

deve estar sempre do mesmo lado em que se encontra a variável da cadeia mínima e esta, por sua vez,
deve-se orientar sempre pela linguagem.
A cadeia mínima, nós já aprendemos a identificar no capítulo anterior. A replicação é facilmente

identificada quando construímos a árvore sintática da estrutura. Uma árvore de análise sintática, ou
simplesmente árvore sintática, é uma estrutura de dados em árvore, que representa a estrutura sintática
de uma cadeia de acordo com alguma gramática formal. Isto significa que cada cadeia válida terá uma
árvore sintática que a representa e nenhuma cadeia inválida terá essa árvore sintática.
33
Para analisarmos melhor as árvores sintáticas, primeiramente vamos listar as cadeias válidas da
linguagem:
C = {01, 0011, 000111, 00001111, 0000011111, 000000111111, 00000001111111, ...}.
Agora vamos construir as árvores sintáticas para algumas destas cadeias.
Com essa árvore sintática chegamos à conclusão que S = 01. E as

demais cadeias, como poderão ser geradas?
A resposta para essa pergunta é simples: Recursão.
Árvore sintática da
cadeia mínima
Sabemos que S = 01, agora imagine a segunda cadeia válida: 0011, assim temos: 0011 = 0S1. No
caso da terceira cadeia válida temos: 000111 = 00S11, e assim por diante. Vejamos as árvores
sintáticas:
Árvore sintática da segunda cadeia válida Árvore sintática da terceira cadeia válida
Com isso chegamos à conclusão que S = 0S1, ficando assim a função de produção:
δ S= 0S1 ∪ 01
Replicação Obrigatória
Assim podemos observar, por exemplo: S = 0S1 = 00S11 = 000S111 = 00001111

Com isso, nossa primeira gramática fica assim:
• V = S;
• Σ = 0, 1;
• S0 = S;
• δ S = 0S1 ∪ 01
34
Exemplo 2: Vejamos a gramática abaixo:
• V = S, A, B;
• Σ = 0, 1;
• S0 = S;
• δ
o S = 0S ∪ AB
o AB = BA ∪ λ
o A=0
o B=1
Pergunta: Qual é a linguagem geradora desta gramática?

Para responder a essa pergunta vamos apelar para as possíveis árvores sintáticas:
0* 0*01 0*10
Descrevendo todas as possíveis árvores sintáticas da gramática, chegamos à seguinte linguagem:
L = 0* ∪ 0*01 ∪ 0*10
4. GRAMÁTICAS LIVRES-DE-CONTEXTO
Em linguística e Teoria da Computação, gramáticas livres de contexto ou gramáticas independentes

de contexto, de nível 2 na hierarquia de Chomsky, também chamadas gramáticas algébricas são
gramáticas formais onde é levantado o condicionamento das substituições impostas pelas regras
definidas pelas produções. Este condicionamento é eliminado impondo às produções uma restrição
adicional, que restringe as produções à forma geral formalmente descrita como:
∀ α ∈V & β ∈ Σ α = (α∗β∗)∗
Em resumo, toda gramática é classificada como Livre-de-Contexto se, e somente se, no lado esquerdo
da igualdade de cada produção existe uma e apenas uma variável.
35
4.1. SEPARAÇÃO DE VARIÁVEIS DAS GRAMÁTICAS LIVRES-DE-CONTEXTO
Antes de iniciarmos os exemplos, vamos a uma pergunta importante: É possível saber a quantidade
de variáveis que se precisa declarar, apenas observando a linguagem?
A resposta para essa pergunta é SIM! Para cada tipo de Gramática, com restrições, existe uma forma
diferente de se saber a quantidade de variáveis a serem declaradas.
Em todas as gramáticas, devemos isolar os elementos independentes de uma linguagem, pois cada
um desses elementos será uma variável.
Exemplo 01:
Separando os elementos da linguagem: L = 0*1+(10)+1011*, temos:
L= 0* 1+ (10)+ 1 0 1 1*
Neste exemplo identificamos sete variáveis.
Nas Gramáticas Livre-de-Contexto, as variáveis devem ser contadas de fora para dentro. Os
elementos variáveis (de expoente N, M, etc.) são dependentes entre si, por isso, contam apenas uma
única variável cada um. Esses elementos variáveis só devem ser contados quando todos os elementos
a esquerda do primeiro e a direita do segundo já o foram.
Exemplo 02:
Separando os elementos da linguagem: L = 01N1+(110)+010N11*, temos:
S D E F G B A
L= 0 1N 1+ (110)+ 0 1 0N 1 1*
Neste exemplo identificamos oito variáveis.
Nas Gramáticas Livres-de-Contexto, além do que já foi exposto, a contagem de variáveis possui
algumas particularidades.
1 – Na União, o sinal da união é uma variável e essa variável representa todas as uniões simples da
linguagem;
2 – Quando todos os elementos da linguagem estão dentro de um fecho, esse fecho será uma variável
e será contado antes de seus elementos internos;
3 – A estrutura que reconhece todas as cadeias de uma linguagem, o qual chamamos de “qualquer
coisa”, será uma única variável;
4 – Quando existir um fecho dentro de outro, o fecho interno é uma variável independente da variável
do fecho externo e não será contado na sequência normal da gramática;
36
Exemplo 03:
Separando os elementos da linguagem:

L = (1 0N 1* (01*0)+ 0M 1* 0+ 0M 01N 2*)* ∪ (0*1*2*)* (10)N1 0 1N(2+0)+1* temos:
B E F I J G C A S K R T P L
L = (1 0N 1* (01*0)+ 0M 1* 0+ 0M 0 1N 2*) * ∪ (0*1*2*)* (10)N 1 0 1N (2+0)+ 1*
α H γ
D Q
Neste exemplo identificamos dezenove variáveis.
Importante: Para saber o posicionamento das variáveis nas produções, deve-se sempre orientar-se
pela linguagem, ou seja, na linguagem, a próxima variável está na direita ou na esquerda na variável
que está sendo resolvida. Se ela estiver na direita, a variável deve aparecer à direita dos elementos do
alfabeto que compõe a produção, o mesmo acontece quando a variável está a esquerda ou dentro da
variável que está sendo resolvida. Numa mesma produção as variáveis devem estar sempre no mesmo
lado (em construções normais).
4.2. LEMAS DAS GRAMÁTICAS LIVRES-DE-CONTEXTO
Atenção: Nos exemplos deste subtópico, os três elementos iniciais da gramática (V, Σ e S0) foram
omitidos a fim de simplificar os exemplos. Lembre-se que nas questões e provas isto não será
tolerado.
Lema 01: Elementos Constantes. Cada constante é uma variável e a produção não possui a parte
“replicação”, pois uma constante é estática.
Exemplo: L = 01 δ S = 0A
A=1
Lema 02: Fecho Positivo. No fecho positivo, a parte replicação e a parte obrigatória são formadas
pelo elemento que compõe o fecho.
Exemplo: L = 0+1 δ S = 0S ∪ 0A
A=1
Lema 03: Fecho Estrela. No fecho estrela, a parte replicação se dá como no fecho positivo e a parte
obrigatória é vazia.
Exemplo: L = 0*1 δ S = 0S ∪ λA ou S = 0S ∪ A
A=1 A=1
37
Lema 04: Fecho com mais de um elemento constante. Quando existir duas ou mais constantes
dentro de um fecho, esse fecho será uma única variável e as constantes tratadas como se fossem
apenas uma.
Exemplo: L = (0101)+1 δ S = 0101S ∪ 0101A

A=1
Lema 05: Expoentes variáveis. Este lema também é chamado de Lema do Triângulo. Em expoentes
variáveis, a parte replicação é formada pelos elementos que estão na primeira variável em quantidade
do coeficiente desta primeira variável, seguido de V (antes da igualdade), seguido pelos elementos
que estão na segunda variável em quantidade do coeficiente desta segunda variável. A parte
obrigatória é formada pelos elementos que estão na primeira variável em quantidade do coeficiente
desta primeira variável multiplicado pelo valor nominal da variável, seguido de V (o próximo caso
exista), seguido pelos elementos que estão na segunda variável em quantidade do coeficiente desta
segunda variável também multiplicado pelo valor nominal da variável.
Exemplo 01: L = (01)N 1 (10)N / N ≥ 2 δ

S = 01S10 ∪ 0101A1010
A A=1
Detalhamento do exemplo: o coeficiente de ambos os N’s é 1 portanto, na parte replicação teremos

uma vez os elementos dentro do expoente de cada lado. O valor nominal de N é 2, portanto, na parte
obrigatória, teremos 2 (valor nominal de N) * 1 (coeficiente de N) elementos dentro do exporte de
cada lado.
Exemplo 02: L = (21)3N 1 (2)4N / N ≥ 3
δ S = 212121S2222 ∪ 212121212121212121A222222222222
A=1
Detalhamento do exemplo: o coeficiente do primeiro N é 3 e do segundo é 4, portanto na parte

replicação aparecem três elementos ‘21’ (que estão na primeira variável) e quatro elementos ‘2’ que
está na segunda variável. O valor nominal de N é 3 (N≥ 3), portanto, na parte obrigatória, aparece
nove elementos ‘21’ (três do coeficiente vezes três do valor nominal) e doze elementos ‘2’ (quatro do
coeficiente vezes três do valor nominal).
Lema 06: Fecho geral. Quando um fecho engloba toda a linguagem, esse fecho é contado como uma
variável e é feito antes dos elementos internos. Sua parte replicação é composto pela variável antes
da igualdade, seguido da primeira variável interna ao fecho. Sua parte obrigatória é formada por
vazio, em caso de fecho estrela ou da primeira variável interna ao fecho, no caso de fecho positivo.
Exemplo 01: L = (0 2* 0 1+ 0) *
ABCDE S δ S = SA ∪ λ
A = 0B
B = 2B ∪ C
C = 0D
D = 1D ∪ 1E
E=0
38
Exemplo 02: L = (0 2* 0 1+ 0) +
ABCDE S δ S = SA ∪ A
A = 0B
B = 2B ∪ C
C = 0D
D = 1D ∪ 1E
E=0
Lema 07: Todas as cadeias. A estrutura que representa todas as cadeias é representada pela união
de seus elementos em separado, com a variável antes da igualdade, unido a próxima variável, ou a
vazio, caso a próxima variável não exista.
Exemplo: L = (0*1*2*)* 1 δ S = 0S ∪ 1S ∪ 2S ∪ A
A=1
Lema 08: Fecho dentro de outro fecho. Quando existir um fecho dentro de outro, o fecho interno
será nomeado com uma variável fora da sequência normal e resolvido a parte. O fecho externo
continua sendo resolvido com os lemas anteriores, sendo usada a variável do fecho interno ao invés
do elemento que compõe esse fecho interno.
Atenção: O “qualquer coisa” possui seu lema próprio e não pode ser resolvido com este lema 07.
Exemplo: L = 1 (00*1)+ 1
δ S = 1A
S α AB A = 0α1A ∪ 0α1B
B=1
α = 0α ∪ λ
Lema 09: União. As uniões simples, presentes em uma linguagem, são representadas por uma única
variável formada pela união da primeira variável de cada lado das uniões da linguagem. Cada lado da
união é totalmente independente dos demais, ou seja, uma variável de um lado da união não aparece
nas produções de um outro lado qualquer.
Exemplo: 0* ∪ 1+ ∪ (10)*0
δ S=A∪B∪C
A SB S C D A = 0A ∪ λ
B = 1B ∪ 1
C = 10C ∪ D
D=0
39
4.3. FORMAS NORMAIS DAS GRAMÁTICAS LIVRES-DE-CONTEXTO
As Formas Normais são maneiras diferentes de se escrever uma mesma gramática. Cada pesquisador
pode descrever uma Forma Normal, desde que descreva também para qual propósito sua Forma
Normal está sendo criada. Uma gramática é dita normalizada em relação a um certo padrão quando
todas as suas produções satisfazem as restrições impostas pelo padrão em questão.
As formas normais estabelecem restrições rígidas na definição das produções, sem reduzir o poder de
geração das Gramáticas Livres de Contexto, ou seja, todas as cadeias válidas pela gramática original,
também serão válidas na gramática em sua Forma Normal, o mesmo acontece com as cadeias
inválidas. São usadas principalmente no desenvolvimento de algoritmos (com destaque para
reconhecedores de linguagens) e na prova de teoremas.
Vamos conhecer agora as três Formas Normais mais importantes para a Teoria da Computação, seu
propósito e sua formação. Para exemplificar essas Formas Normais que iremos apresentar, vamos
utilizar a seguinte gramática:
• V = S, A, B, C, D, E;
• Σ = 0, 1;
• S0 = S;
• δ S = 00S11 ∪ 00A11
A = A10 ∪ B
B = 0C
C = 00C ∪ 00D
D = 0D ∪ 1D ∪ E
E = 01 ∪ 111 ∪ λ
FORMA NORMAL DE CHOMSKY
As gramáticas possuem uma função essencial no projeto de um compilador e as gramáticas livres-de-

contexto são as mais adequadas para este tipo de projeto. Uma gramática Livre-de-Contexto na Forma
Normal de Chomsky é a maneira mais legível de se descrever um compilador.
Na Forma Normal de Chomsky, em cada produção, só poderá existir variáveis ou alfabetos, ou seja,
nunca existirá um elemento do alfabeto concatenado com uma variável em alguma produção.
Passos da Construção:
1 – Deve-se declarar X variáveis, onde X é a quantidade de elementos que compõe o

alfabeto;
2 – Cada uma destas novas variáveis deve substituir um dos elementos do alfabeto na
gramática;
3 – Ao final da gramática, deve ser acrescentado o significado de cada variável, ou seja, qual
elemento do alfabeto aquela nova variável representa.
40
Exemplo:
• V = S, A, B, C, D, E, F, G; { Passo 01}
• Σ = 0, 1;
• S0 = S;
• δ S = FFSGG ∪ FFAGG
A = AGF ∪ B
B = FC Passo 02
C = FFC ∪ FFD
D = FD ∪ GD ∪ E
E = FG ∪ GGG ∪ λ
F=0 Passo 03
G=1
FORMA NORMAL DE GREIBACH
Estruturas com o mesmo poder podem ser transformadas umas nas outras. Para facilitar a
transformação de uma gramática Livre-de-Contexto em um Autômato a Pilha (assunto que veremos
no capítulo seguinte) é necessário que esta gramática esteja na Forma Normal de Greibach. Esta
Forma Normal foi criada por Sheila A. Greibach (Nova York, 1939 – Doutora por Harvard e
Professora na Universidade da Califórnia) e é criada com os passos a seguir.
1 – Deve-se declarar X variáveis, onde X é a quantidade de elementos que compõe o

alfabeto;
2 – Cada uma destas novas variáveis deve substituir um dos elementos do alfabeto na
gramática, exceto o elemento inicial da gramática, de cada lado da união, caso este elemento
pertença ao alfabeto;
3 – Ao final da gramática, deve ser acrescentado o significado de cada variável, ou seja, qual
elemento do alfabeto aquela nova variável representa.
Exemplo:
• V = S, A, B, C, D, E, F, G; { Passo 01}
• Σ = 0, 1;
• S0 = S;
• δ S = 0FSGG ∪ 0FAGG
A = AGF ∪ B
B = 0C Passo 02
C = 0FC ∪ 0FD
D = 0D ∪ 1D ∪ E
E = 0G ∪ 1GG ∪ λ
F=0 Passo 03
G=1
41
FORMA NORMAL DE BACKUS
Nem sempre é fácil de ler uma gramática, ainda mais com as diferenças de alfabetos em idiomas
estrangeiros, como o japonês e o árabe. Para facilitar a leitura das gramáticas, sejam elas escritas em
qualquer idioma, ou qualquer conjunto de ideogramas, foi criado um padrão internacional para se
escrever uma gramática, esse padrão é a Forma Normal de Backus. Também chamada de Formalismo
de Backus-Naur ou Forma de Panini-Backus, esta Forma Normal foi assumida por comitês
internacionais e tem seu nome em homenagem a John Backus (Filadélfia, 31 de dezembro de 1924 –
Ashland, 17 de março de 2007), um dos criadores do Fortran e contribuinte deste formalismo.
A construção desta forma normal é bem simples, basta substituir os sinais utilizados, pelos sinais do
padrão.
1 – Acrescentar os sinais de <, na esquerda de todas as variáveis e > a sua direita
2 – Substituir todos os símbolos que representa a união, por |
3 – Substituir as igualdades das produções por ::=
Exemplo:
• V = <S>, <A>, <B>, <C>, <D>, <E>
• Σ = 0, 1
• S0 = <S>
• δ <S> ::= 00<S>11 | 00<A>11
<A> ::= <A>10 | <B>
<B> ::= 0<C>
<C> ::= 00<C> | 00<D>
<D> ::= 0<D> | 1<D> | <E>
<E> ::= 01 | 111 | λ
42
5. GRAMÁTICAS REGULARES
As Gramáticas Regulares, de nível 3 na Hierarquia de Chomsky e que possuem as maiores restrições

sobre a forma de suas produções, são de grande importância no estudo dos compiladores por
possuírem propriedades adequadas para a obtenção de reconhecedores simples.
O Poder das Gramáticas Regulares é o mesmo dos Autômatos Finitos, ou seja, reconhecem apenas
Linguagens Regulares.
Toda Gramática Regular é dita Linear. Uma gramática é linear quando suas produções geram
resultados com apenas uma ou nenhuma variável, sendo que esta variável, caso exista, deve aparecer
sempre na extrema direita, neste caso diz-se Gramática Linear a Direita, ou na extrema esquerda,
neste caso diz-se Gramática Linear à Esquerda, não permitindo composições hibridas. Portanto, para
que uma gramática possa ser classificada como regular, a restrição em suas produções formalmente
descrita é:
∀ α,γ ∈V & β ∈ Σ α = β∗γ ou α = β∗ , para as gramáticas regulares lineares à direita ou

∀ α,γ ∈V & β ∈ Σ α = γβ∗ ou α = β∗ , para as gramáticas regulares lineares à esquerda;
Em resumo, toda gramática é regular se, e somente se, exista apenas uma variável no lado esquerdo
da igualdade de cada produção e, em seu lado direito, exista no máximo uma variável de cada lado
da união, sendo que essa variável, caso exista, está sempre na extrema direita (gramática regular linear
à direita) ou na extrema esquerda (Gramática Regular linear à esquerda).
Atenção: Se uma variável aparece na extrema esquerda e, em outra produção, aparece uma variável
na extrema direita, essa gramática não é regular.
Exemplo de produções que não fazem parte de uma gramática regular:
S = 00S ∪ 00A S = 00S00 ∪ 0000

A = A0 ∪ 0
5.1. SEPARAÇÃO DE VARIÁVEIS DAS GRAMÁTICAS REGULARES
Nas gramáticas regulares, a forma de contagem de variáveis é diferente da forma aprendida para as
demais gramáticas. Existem duas formas de se contar as variáveis de uma linguagem regular. “Da
esquerda para a direita”, seguindo uma linha linear ou “Da direita para a esquerda”, também seguindo
uma linha linear.
Caso a contagem de variáveis seja feita “da esquerda para a direita”, o resultado será uma gramática
regular linear à direita, caso a contagem seja feita “da direita para a esquerda”, o resultado será uma
gramática regular linear à esquerda. Ambas as contagens sempre geram resultados corretos em
linguagens regulares.
Vejamos um exemplo de uma mesma linguagem regular, tendo suas variáveis contadas das duas
formas.
43
Exemplo: L = 0*103N (100)* 1+ 012M 0* / N ≥ 0 e M ≥ 2
Contagem da esquerda para a direita Contagem da direita para a esquerda
L = 0* 1 03N (100)* 1+ 0 12M 0* L = 0* 1 03N (100)* 1+ 0 12M 0*
S AB C D E F G G F E D C B A S
V = S, A,B ,C, D, E, F, G V = S, A,B ,C, D, E, F, G

Σ = 0, 1 Σ = 0, 1
S0 = S S0 = S
δ δ
S = 0S ∪ 0A S = S0 ∪ A
A = 1B A = A11 ∪ B1111
B = 000B ∪ C B = C0
C = 100C ∪ D C = C1 ∪ D1
D = 1D ∪ 1E D = D100 ∪ E
E = 0F E = E000 ∪ F
F = 11F ∪ 1111G F = G1
G = 0G ∪ λ G = G0 ∪ λ
Atenção: Os mandamentos das gramáticas regulares são os mesmos das gramáticas livres-de-
contexto, exceto os lemas 5, 6 e 8 que não podem ser usados nas gramáticas regulares devido as suas
restrições de construção das produções.
Importante: Para saber o posicionamento das variáveis nas produções, deve-se sempre orientar-se
pela linguagem, ou seja, na linguagem, a próxima variável está na direita ou na esquerda na variável
que está sendo resolvida? Se ela estiver na direita, a variável deve aparecer à direita dos elementos
do alfabeto que compõe a produção, o mesmo acontece quando a variável está a esquerda. Em
gramáticas regulares as variáveis devem estar sempre no mesmo lado.
44
5.2. PROPRIEDADES DAS GRAMÁTICAS REGULARES
Algumas propriedades podem ser aplicadas às gramáticas regulares. Vejamos a seguir cada uma
delas.
CONCATENAÇÃO ( // )
Concatenar duas gramáticas regulares significa concatenar todas as cadeias válidas da primeira
gramática, uma a uma, com todas as cadeias válidas da segunda gramática, criando um novo conjunto
de cadeias válidas.
Atenção: Duas ou mais gramáticas regulares só poderão ser concatenadas se forem lineares para o
mesmo lado.
A concatenação de duas gramáticas regulares G1 e G2 (G1//G2) se dá através da seguinte regra:
1 – V = VG1 ∪ VG2;
2 – Σ = ΣG1 ∪ ΣG2;
3 – S0 = S0G1;
4–δ
4.1 – δG1;
4.2 – Acrescentar S0G2 em todas as produções da etapa 4.1 que não possuam
variáveis;
4.3 – δG2;
Atenção: No item 4.2, as inserções de S0G2 serão feitas a direita, quando a gramática regular for
linear à direita ou a esquerda, quando a gramática regular for linear a esquerda.
A concatenação de duas gramáticas regulares gera uma nova gramática cuja linguagem reconhecida
é exatamente a concatenação das cadeias válidas na primeira gramática, com as cadeias válidas na
segunda gramática.
Exemplo:
G1 G2 G1 // G2
V = S’, A, B, C V = S’’, D, E V = S’, S’’, A, B, C, D, E
Σ = 0, 1 Σ = 0, 1, 2 Σ = 0, 1, 2
S0 = S’ S0 = S’’ S0 = S’
δ δ δ
S’ = 0S’ ∪ 0A S’’ = S’’20 ∪ D S’ = 0S’ ∪ 0A
A = 1B ∪ λ D = D121 ∪ E111 ∪ 01 ∪ λ A = 1B ∪ λS’’
B = 000B ∪ C ∪ 00 E = E10 ∪ 22 B = 000B ∪ C ∪ 00 S’’
C = 10 ∪ 01 ∪ λ C = 10 S’’ ∪ 01 S’’ ∪ λS’’
S’’ = S’’20 ∪ D
D = D121 ∪ E111 ∪ 01 ∪ λ
E = E10 ∪ 22
45
UNIÃO ( ∪ )
Unir duas gramáticas regulares significa validar todas as cadeias válidas da primeira gramática e todas
as cadeias válidas da segunda gramática.
Atenção: Duas ou mais gramáticas regulares só poderão ser unidas se forem lineares para o mesmo
lado.
A união de duas gramáticas regulares G1 e G2 (G1 ∪ G2) se dá através da seguinte regra:
1 – V = VG1 ∪ VG2 ∪ N; // onde N é uma nova variável;

2 – Σ = ΣG1 ∪ ΣG2;
3 – S0 = N;
4–δ
4.1 – Acrescentar a produção: N = S0G1 ∪ S0G2
4.2 – δG1 e δG2;
A união de duas ou mais gramáticas regulares gera uma nova gramática que reconhece todas as
cadeias válidas da primeira e da segunda gramática.
Exemplo:
G1 G2 G1 ∪ G2
V = S’, A, B, C V = S’’, D, E V = S’, S’’, A, B, C, D, E, N
Σ = 0, 1 Σ = 0, 1, 2 Σ = 0, 1, 2
S0 = S’ S0 = S’’ S0 = N
δ δ δ
S’ = 0S’ ∪ 0A S’’ = S’’20 ∪ D N = S’ ∪ S’’
A = 1B ∪ λ D = D121 ∪ E111 ∪ 01 ∪ λ S’ = 0S’ ∪ 0A
B = 000B ∪ C ∪ 00 E = E10 ∪ 22 A = 1B ∪ λ
C = 10 ∪ 01 ∪ λ B = 000B ∪ C ∪ 00
C = 10 ∪ 01 ∪ λ
S’’ = S’’20 ∪ D
D = D121 ∪ E111 ∪ 01 ∪ λ
E = E10 ∪ 22
46
CONJUNTO CLAUSURA ( * )
O conjunto clausura é o fecho de uma gramática. Colocar a gramática em clausura significa validar
todas as suas cadeias já válidas e todas as cadeias formadas pela concatenação sucessivas dessas
cadeias válidas, com elas mesmas, até o infinito, ou seja, se a cadeia 0010 é válida na gramática
original, na gramática com clausura, serão válidas, além da própria cadeia 0010, as cadeias 00100010,
001000100010, 0010001000100010, ..., além da cadeia vazia (no caso do clausura estrela).
O Conjunto Clausura Estrela de uma gramática regular G1, representado por G1* se dá através da
seguinte regra:
1 – V = VG1, N;
2 – Σ = ΣG1;
3 – S0 = N;
4–δ
4.1 – Incluir N = S0G1 ∪ λ;
4.2 – Acrescentar N em todas as produções da etapa 4.1 que não possuam
variáveis;
O conjunto clausura de uma gramática gera uma nova gramática cuja linguagem é a estrela de Kleene
da gramática anterior.
Exemplo:
G1 G1*
V = S’, A, B, C V = S’, A, B, C, N
Σ = 0, 1 Σ = 0, 1
S0 = S’ S0 = N
δ δ
S’ = 0S’ ∪ 0A N = S’ ∪ λ // Etapa 4.1
A = 1B ∪ λ S’ = 0S’ ∪ 0A
B = 000B ∪ C ∪ 00 A = 1B ∪ λN Etapa 4.2
C = 10 ∪ 01 ∪ λ B = 000B ∪ C ∪ 00N
C = 10N ∪ 01N ∪ λN
Para fazer o chamado “Clausura Positivo”, ou seja, o fecho positivo de uma gramática regular, a regra
é a mesma para o clausura estrela, com uma única exceção, a produção inicial não será a nova variável.
Ela permanece sendo a produção inicial da gramática G1
G1 G1+
V = S’, A, B, C V = S’, A, B, C, N
Σ = 0, 1 Σ = 0, 1
S0 = S’ S0 = S’  ATENÇÃO
δ δ
S’ = 0S’ ∪ 0A N = S’ ∪ λ // Etapa 4.1
A = 1B ∪ λ S’ = 0S’ ∪ 0A
B = 000B ∪ C ∪ 00 A = 1B ∪ λN Etapa 4.2
C = 10 ∪ 01 ∪ λ B = 000B ∪ C ∪ 00N
C = 10N ∪ 01N ∪ λN
47
6. GRAMÁTICAS SENSÍVEIS-AO-CONTEXTO
As Gramáticas Sensíveis-ao-Contexto, de nível 1 na Hierarquia de Chomsky e também chamadas de

monotônicas ou não-contráteis, são o elo de ligação entre as gramáticas livres-de-contexto e as
gramáticas irrestritas. Se as regras de substituição forem impostas à restrição de que nenhuma
substituição possa reduzir o comprimento da forma sentencial à qual a substituição é aplicada, temos
uma gramática Sensível-ao-Contexto.
Formalmente falando, toda gramática é Sensível-ao-Contexto se, e somente se:
∀ α ∈(V ∪ Σ)+ & β ∈ (V ∪ Σ)* α = β, onde | α | ≤ | β |
Em resumo, toda gramática é Sensível-ao-Contexto se, e somente se, a quantidade de elementos do

lado esquerdo de cada produção for menor ou igual do que a quantidade de elementos do lado direito
de cada produção.
6.1. SEPARAÇÃO DE VARIÁVEIS DAS GRAMÁTICAS SENSÍVEIS-AO-CONTEXTO
Nas gramáticas Sensíveis-ao-Contexto, a forma de contagem de variáveis é similar a forma aprendida

para as demais gramáticas. Nelas, cada expoente é uma variável, mesmo os expoentes que são
interdependentes, como os expoentes variáveis.
Devemos isolar todos os elementos da uma linguagem, pois cada um desses elementos será uma
variável. A forma de contagem continua sendo a mesma usada nas gramáticas livres-de-contexto, ou
seja, “de fora para dentro”, porém, os expoentes iguais que tiverem três ou mais aparições, devem ser
contados seqüencialmente da esquerda para a direita, como nas gramáticas regulares lineares à direita.
Os expoentes variáveis com exatamente duas aparições, mantêm a regra de contagem das gramáticas
livres-de-contexto.
Exemplo 01:
L = 0* 0N (10)* 0M 1M 22M 0* 0M 1 2N (1 1+ 0 2)* 0 ∪ 0 1N 0/ N ≥ 2 e M ≥ 1
A E G H I J K F α C BS L P Q
D
Para se construir uma gramática Sensível-ao-contexto, devemos ter em mente que todas as regras de
construção das gramáticas livres-de-contexto serão utilizadas em todas as produções, exceto naquelas
que fizerem parte da estrutura que possui três ou mais aparições de um expoente variável. Nestas
estruturas, serão seguidos os três passos seguintes:
Atenção: Essa regra faz referência sempre parte da linguagem que vai do primeiro expoente variável
ao último expoente variável que compõe a parte dita sensível da linguagem. A essa parte vamos
chamar apenas de estrutura.
1 – Replicação & Cadeia Mínima: Será criada uma produção. Do lado esquerdo da produção será
colocada a primeira variável da estrutura. Na replicação existirá o alfabeto que compõe a primeira
variável da estrutura, em quantidade igual ao coeficiente de seu expoente, seguido da variável antes
da igualdade, seguido direto das demais variáveis que representam os expoentes variáveis da
estrutura, na quantidade do coeficiente de seus respectivos expoentes. A cadeia mínima será formada
pelo alfabeto que compõe a primeira variável da estrutura, em quantidade igual ao coeficiente de seu
48
expoente, seguido pelas demais variáveis que compõe a estrutura, em quantidade igual ao seu
coeficiente, ou apenas uma aparição, caso seja um elemento constante.
2 – Ordem Alfabética: Colocar em ordem alfabética, pares de dois em dois, de todas as variáveis
que compõe a estrutura.
3 – Substituição: Para cada variável da estrutura, que representa um elemento com expoente variável,
exceto o primeiro, existirão duas produções formadas da seguinte maneira:
2.1. Do lado esquerdo da igualdade existirá o elemento do alfabeto que aparece, na

linguagem, antes da variável, seguido da própria variável. Do lado direito da igualdade,
existirá o elemento do alfabeto agora mencionado e o elemento do alfabeto representado
pela variável em questão.
2.2. Do lado esquerdo da igualdade existirá o elemento do alfabeto que representa a variável
em questão, seguido da própria variável. Do lado direito da igualdade, existirá duas vezes
o elemento do alfabeto representado pela variável em questão.
Para os elementos constantes, serão criadas produções para cada um deles em separado, onde não
existirá próxima variável. Como exemplo destes passos, vamos resolver a linguagem do exemplo 01
deste tópico.
V = S, A, B, C, D, E, F, G, H, I, J, K, L, P, Q, α
Σ = 0, 1, 2
S0 = S
δ S=A∪L
A = 0A ∪ B
B = C0
C = C1α02 ∪ D
D = 0D2 ∪ 00E22
E = 10E ∪ F
F = G1
G=0GHIIK ∪ 0HIIJK // Passo 01
IH=HI
JH=HJ
KH=HK // Passo 02
JI=IJ
KI=IK
KJ=JK
0H=01
1H=11
1I=12 // Passo 03
2I=22
0K=00
2K=20
0K=00 // não é necessária a duplicidade
J = 0J ∪ λ
α=1α∪1
L=0P
P = 1 P ∪ 11Q
Q=0
49
Importante: Pergunta: É possível saber qual gramática será construída apenas olhando para a
linguagem? A resposta é GERALMENTE SIM. Tudo depende da quantidade de expoentes variáveis
iguais, em cada lado da união, que a linguagem possui. Caso exista apenas uma aparição de cada um
dos expoentes variáveis da linguagem, deverá ser construída uma gramática regular; caso existam
duas aparições de um mesmo expoente variável, deverá ser construída uma gramática Livre-de-
Contexto, caso existam três ou mais expoentes variáveis iguais, então a gramática é Sensível-ao-
Contexto. Essa regra possui algumas exceções, que só podem ser verificadas durante a construção da
gramática, mas funciona de modo geral.
50
APOSTILA DE LINGUAGENS FORMAIS – AUTÔMATOS A PILHA Prof. TENORIO
5. AUTÔMATOS A PILHA
Vimos que o poder dos Autômatos Finitos limita-se as Linguagens Regulares. Para representar as
linguagens não-regulares recorremos a estruturas mais poderosas. Isto se deve ao fato dos autômatos
não terem estruturas de memória para auxiliá-los, como as variáveis nas gramáticas.
Para resolver este problema, pesquisadores da área foram atrás de uma estrutura de memória, que
pudesse ser vinculada aos autômatos finitos, a fim de que estes passassem representar também as
linguagens não-regulares. Várias estruturas de dados foram testadas e chegou-se a conclusão de que
a melhor estrutura para essa tarefa seria a pilha. As pilhas são estruturas baseadas no princípio LIFO
(last in, first out), na qual os dados que foram inseridos por último na pilha serão os primeiros a serem
removidos. Da fusão dos Autômatos Finitos com a estrutura de dados Pilha, nasceram os Autômatos
a Pilha.
O poder dos autômatos a pilha engloba as linguagens regulares e também as não-regulares. O quadro
a seguir mostra um comparativo de poder entre o autômato a pilha e as gramáticas da Hierarquia de
Chomsky.
Gramáticas Autômatos
Gramáticas Regulares Autômatos Finitos
Gramáticas Livres-de-Contexto Autômatos a pilha, utilizando-se de apenas uma pilha
Gramáticas Sensíveis-ao-Contexto Autômatos a pilha, utilizando-se de duas pilhas
Gramáticas com Estrutura de Frase Autômatos a pilha, utilizando-se de três ou mais pilhas
Importante: Vale lembrar que o principal objetivo dos autômatos é a validação de cadeias. Para uma
cadeia ser válida no autômato a pilha, não é suficiente que a cadeia termine em um estado final. Para
que uma cadeia possa ser validada em um autômato a pilha, duas condições devem ser
obrigatoriamente satisfeitas: sua chegada em um estado final e a pilha estar vazia, não podendo sobrar
ou faltar elementos.
1. CONCEITO
O conceito de Autômato a Pilha, formalmente falando, é uma sétupla, formada por:
Esse conceito nos mostra que o autômato a pilha, nada mais é do que o autômato finito, unido as
estruturas de pilha.
Explicando os elementos que compõe o autômato a pilha:
51
• Q é um conjunto finito não vazio de estados do autômato à pilha.
• ∑ é um conjunto finito não vazio de símbolos de entrada ou átomos, denominado alfabeto de

entrada do autômato à pilha. Os símbolos de entrada são os elementos de que são formadas
as cadeias de entrada submetidas ao autômato para aceitação;
• S0 é denominado estado inicial do autômato à pilha, e é um elemento do conjunto Q. É o

estado em que se deve encontrar o autômato à pilha imediatamente antes do início do
reconhecimento de uma cadeia de entrada (q0∈ Q);
• F é um subconjunto do conjunto de estados Q do autômato, que contém todos os chamados

estados finais ou estados de aceitação do autômato de pilha. Tais estados
correspondem àqueles nos quais o autômato de pilha deve encerrar o reconhecimento de todas
as cadeias de entrada que sejam sentenças da linguagem definida pelo autômato à pilha.
Nenhuma outra cadeia deve finalizar o autômato em qualquer destes estados;
• δ é a chamada função de transição do autômato à pilha, e é composta de um conjunto de

produções que definem as regras de movimentação do autômato à pilha. Esta função mapeia
o produto cartesiano E X (V ∪ {λ}) X P no produto cartesiano E X P*. Em palavras, dado um
estado, um símbolo de entrada e um símbolo de pilha contido no topo da memória auxiliar,
esta função determina um novo estado do autômato e o novo conteúdo do topo da pilha (de
comprimento qualquer);
• ΣP é um conjunto finito não vazio de símbolos da pilha, e forma o alfabeto da pilha. Os

símbolos da pilha são os códigos armazenados pelo autômato em sua memória auxiliar. Esta
memória, no caso do autômato à pilha, é organizada na forma de uma pilha, ou seja, os últimos
dados armazenados são os primeiros a serem lidos da pilha, e vice-versa;
• Z0 é um elemento do conjunto ΣP, distinto dos demais pela convenção de que sua presença,
no topo da pilha que implementa a memória do autômato, indica a ausência de outros
elementos na mesma. É um marcador de pilha vazia (z0∈ ΣP);
2. CONVENÇÕES
Para facilitar o estudo e a construção dos autômatos a pilha, vamos conhecer algumas convenções
adotadas pelos mais diversos autores.
1) A função de produção será representa em uma tabela, cujas linhas expressam o estado
atual e o topo da pilha e as colunas, os elementos do alfabeto.
3) Existirá apenas um estado final e este não será o inicial e nem terá saída alguma;
4) Z0 será sempre Z e estará sempre na base da pilha. Não poderá existir outro elemento Z
na pilha e o último comando de todo autômato a pilha será desempilhar este Z;
52
3. DETERMINISMO
O conceito do determinismo em um autômato a pilha é um pouco diferente do conceito de

determinismo em um autômato finito. Um autômato a pilha é dito Determinístico se, e somente se,
para cada elemento do alfabeto exista, no máximo, uma transição de saída, de cada estado e cada
elemento no topo da pilha, pertencente ao autômato, ou seja, um mesmo elemento do alfabeto, com
um mesmo elemento no topo da pilha, não pode ter duas ou mais transições de saída de um mesmo
estado, porém, não existe a obrigatoriamente dessa saída existir, ou seja, pode não haver saída de
alguns estados em um autômato a pilha determinístico.
Em relação ao poder, o autômato a pilha não-determinístico é mais poderoso do que o autômato a

pilha determinístico, ou seja, existem linguagens reconhecidas por um autômato a pilha não-
determinístico, que o autômato a pilha determinístico não é capaz de resolver. Devido a essa diferença
de poder, não é possível converter um autômato a pilha não-determinístico qualquer em um autômato
a pilha determinístico, como é feito com os autômatos finitos.
4. CONSTRUÇÃO DOS AUTÔMATOS A PILHA
Construir um Autômato a Pilha é escrever toda sua sétupla. Ao contrário do Autômato Finito, a cadeia
mínima não é uma cadeia interessante para se construir um Autômato a Pilha, pois, as particularidades
dos loops não são tão simples de se verificar e requerem um pouco mais de cuidados.
Não existe uma regra para construção dos Autômatos a Pilha, porém, ao se deparar com uma
linguagem qualquer que se queira criar um Autômato a Pilha, algumas dicas podem ser seguidas.
Essas dicas remontam os seguintes passos:
1 – Verificar se os elementos da linguagem estão dentro do alfabeto proposto;
2 – Construir o autômato finito da linguagem, considerando os expoentes variáveis como fechos.

Fecho Estrela, se o valor nominal da variável for 0; Fecho Positivo, se o valor nominal da variável
for 1; Fecho duplamente positivo (dois obrigatórios e um loop), se o valor da variável for 2, e assim
por diante). Para este passo é importante verificar as formas de construção de um autômato finito no
capítulo 2 desta apostila;
3 – Evidenciar uma cadeia não mínima, ou seja, uma cadeia onde os elementos variáveis se replicam,
ao menos, duas vezes;
4 – Montar inicialmente a sétupla, exceto a δ, com as informações extraídas do autômato construído

na fase 2;
5 – Construir a δ, com base nas ligações do autômato, tomando cuidado com os expoentes variáveis
da linguagem, pois nestes, e somente nestes, a pilha (memória auxiliar) deve sofrer alterações;
A tabela da função de transição do autômato a pilha é constituída da seguinte maneira:
53
Elementos do Σ
Σ
Q x ΣP
Estado atual e
Topo atual da pilha
Em cada cruzamento da tabela será colocado o estado destino e o novo elemento do topo da pilha.
Esse elemento do topo da pilha substituirá o elemento da pilha que se encontra na coluna Q x ΣP.
Caso não se queira mexer na pilha, basta repetir o elemento a coluna Q x ΣP, pois isso fará com que
o Autômato a Pilha substitua o elemento por ele mesmo, mantendo assim, a pilha constante.
A ideia do uso da memória auxiliar (pilha) serve apenas para os elementos que precisam ser contados,
por isso, constantes e fechos não a utilizam. No escopo da apostila, só iremos trabalhar com
linguagens livres-de-contexto, portanto só existirá, na linguagem, o máximo de dois expoentes
variáveis iguais de cada lado da união. Esses expoentes são os únicos elementos a usarem a pilha, e
este uso se dará da seguinte maneira: o primeiro expoente variável empilhará N elementos e o segundo
expoente variável, precisará desempilhar exatamente os N elementos empilhados anteriormente, pois,
como já vimos, uma cadeia só será válida se chegar ao estado final com a sua pilha vazia, sem sobrar,
nem faltar elementos.
54
5. LEMAS DO AUTÔMATO A PILHA
Atenção: Lembre-se que ao se construir um autômato a pilha, toda sua sétupla deve ser descrita.
Lema 1: Elementos Regulares. Os elementos constantes e fechos estrelas e positivos são tratados
como se estivéssemos construindo um autômato finito e NÃO alteram a memória auxiliar. Isto
significa que os elementos obrigatórios mudam de estado e os não-obrigatórios não mudam, porém,
na pilha, nada se altera;
Exemplo: L = 01+01*
Q = q0, q1, q2, q3, q4 Q x ΣP 0 1 λ

Σ = 0, 1 q0, Z q1, Z
S0 = q0 q1, Z q2, Z
F = q4 q2, Z q3, Z q2, Z
ΣP = Z q3, Z q3, Z q4, λ
Z0 = Z
Detalhamento: observe o elemento Z destacado na tabela. Como o primeiro zero da linguagem é um

elemento Regular (no caso, constante), o elemento colocado na coluna 0, é apenas uma repetição do
elemento da coluna Q x ΣP.
Lema 2: Elementos Livres-de-Contexto. No caso de aparecer dois elementos com expoentes

variáveis iguais, o primeiro empilha e o segundo, desempilha.
Exemplo: L = 01N01N0 / N ≥ 1
Q = q0, q1, q2, q3, q4, q5, q6 Q x ΣP 0 1 λ

Σ = 0, 1 q0, Z q1, Z
S0 = q0 q1, Z q2, NZ
F = q6 q2, N q3, N q2, NN
ΣP = N, Z q3, N q4, λ
Z0 = Z q4, N q4, λ
q4, Z q5, Z
q5, Z q6, λ
Detalhamento: Para empilhar um elemento, na coluna do Σ em questão, coloque o elemento que se

quer empilhar ao lado do elemento que esteja na coluna Q x ΣP. Para desempilhar, basta colocar o
elemento λ na coluna do Σ em questão.
Atenção: Caso exista apenas uma aparição de um expoente variável, este deve ser tratado como
Elemento Regular.
55
Lema 3: Elementos Livres-de-Contexto com valor nominal maior que 1. Neste caso, o valor
nominal indicará quantas vezes precisarei mudar de estado nos elementos que alteram a pilha.
Exemplo: L = 01N01N0 / N ≥ 3
Q = q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10 Q x ΣP 0 1 λ
Σ = 0, 1 q0, Z q1, Z
S0 = q0 q1, Z q2, NZ
F = q10 q2, N q3, NN
ΣP = N, Z q3, N q4, NN
Z0 = Z q4, N q5, N q4, NN
q5, N q6, λ
q6, N q7, λ
q7, N q8, λ
q8, N q8, λ
q8, Z q9, Z
q9, Z q10, λ
Lema 4: Elementos Livres-de-Contexto compostos. Quando o expoente variável englobar mais um

elemento, apenas o último elemento obrigatório altera o valor da pilha, ou demais NÃO podem alterar
a pilha.
Exemplo: L = 0(10)N0(01+)N0 / N ≥ 1
Q = q0, q1, q2, q3, q4, q5, q6, q7, q8 Q x ΣP 0 1 λ

Σ = 0, 1 q0, Z q1, Z
S0 = q0 q1, Z q2, Z
F = q8 q2, Z q3, NZ
ΣP = N, Z q2, N q3, NN
Z0 = Z q3, N q4, N q2, N
q4, N q5, N
q5, N q6, λ
q6, N q5, N q6, N
q6, Z q7, Z
q7, Z q8, λ
Importante: Note bem o que acontece com o q6. Ele possui duas saídas 0 (zero), uma em direção ao
q5 e outra em direção ao q7, porém isto não desqualifica o determinismo, ou seja, este autômato a
pilha é determinístico, pois q6 só lerá o zero em direção ao q5, quando o topo da pilha for N e só lerá
o zero em direção ao q7, quando o topo da pilha for Z.
56
Lema 5: Vários elementos Livres-de-Contexto. Quando existir mais de um o expoente variável,

basta seguir os demais lemas normalmente. Nada muda.
Exemplo: L = 01N01M01M01N0 / N ≥ 1, M ≥ 1
Q = q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10 Q x ΣP 0 1 λ
Σ = 0, 1 q0, Z q1, Z
S0 = q0 q1, Z q2, NZ
F = q10 q2, N q3, N q2, NN
ΣP = M, N, Z q3, N q4, MN
Z0 = Z q4, M q5, M q4, MM
q5, M q6, λ
q6, M q6, λ
q6, N q7, N
q7, N q8, λ
q8, N q8, λ
q8, Z q9, Z
q9, Z q10, λ
Lema 6: União. Quando, na linguagem, existir a união, nada se altera. Basta iniciar todos os
elementos do q0, assim como no autômato finito. Lembrando que teremos apenas um estado final.
Exemplo: L = 1N01N ∪ 2N02N / N ≥ 1
Q = q0, q1, q2, q3, q4, q5, q6, q7 Q x ΣP 0 1 2 λ

Σ = 0, 1, 2 q0, Z q1, NZ q5, NZ
S0 = q0 q1, N q2, N q1, NN
F = q4 q2, N q3, λ
ΣP = N, Z q3, N q3, λ
Z0 = Z q3, Z q4, λ
q5, N q6, N q5, NN
q6, N q7, λ
q7, N q7, λ
q7, Z q4, λ
Atenção: No caso de união, lembrar sempre do Lema 9 do autômato finito, que também vale no
autômato a pilha.
57
Lema 7: Autômato a Pilha Não Determinístico. Caso parta, de algum estado, duas ou mais saídas
iguais, tendo o mesmo elemento no topo da pilha, dizemos que o autômato a pilha é não-
determinístico.
Exemplo: L = (1N01N0)* ∪ 2N 0(0*1*2*)*0 2N / N ≥ 1
Q = q0, q1, q2, q3, q4, q5, q6, q7, q8, q9 Q x ΣP 0 1 2 λ

Σ = 0, 1, 2 q0, Z q1, NZ q6, NZ q5, λ
S0 = q0 q1, N q2, N q1, NN
F = q5 q2, N q3, λ
ΣP = N, Z q3, N q3, λ
Z0 = Z q3, Z q4, Z
q4, Z q1, NZ q5, λ
q6, N q7, N q6, NN
q7, N q7, N / q7, N q7, N
q8, N
q8, N q9, λ
q9, N q9, λ
q9, Z q5, λ
Atenção: Atentar para o fecho estrela geral (no lado esquerdo na união) e para o “qualquer coisa”, no
lado direito na união. Esses elementos são feitos exatamente como no autômato finito, por isso, não
possuem lemas específicos nos autômatos a pilha.
Importante: Neste exemplo, no lado esquerdo da união, vemos um fecho estrela que abrange toda a
estrutura. Os fechos permitem repetir tudo que está dentro deles. Na repetição, pode ser que seja
necessário garantir que a quantidade de elementos com expoente variável da primeira repetição seja
a mesma das repetições seguintes. Para tornar isto possível, deverão ser criadas duas pilhas de apoio
que irão guardar esse valor e serão chegadas a cada repetição.
Lema 8: Elementos Livres-de-Contexto com coeficientes maiores que 1. No caso das variáveis
dos expoentes livres-de-contexto apresentarem coeficientes, esses coeficientes serão usados apenas
no momento do empilhar e do desempilhar, não alternado, em nada, a sequência dos estados do
autômato a pilha. No momento do empilhar, serão empilhados, simultaneamente, C2 elementos na
pilha, onde C2 é o valor do coeficiente do desempilhar da variável. E no momento de desempilhar,
serão desempilhados, simultaneamente, C1 elementos, onde C1 é o valor do coeficiente do empilhar
da variável.
Exemplo: L = 015N013N0 / N ≥ 1
Q = q0, q1, q2, q3, q4, q5, q6 Q x ΣP 0 1 λ

Σ = 0, 1 q0, Z q1, Z
S0 = q0 q1, Z q2, NNNZ
F = q6 q2, N q3, N q2, NNNN
ΣP = N, Z q3, NNNNN q4, λ
Z0 = Z q4, NNNNN q4, λ
q4, Z q5, Z
q5, Z q6, λ
58
Detalhamento: Neste exemplo, C1 = 5 e C2 = 3, portanto, serão empilhados os elementos de 3 em 3 e

desempilhados de 5 em 5. Atentar para a notação do empilhamento e do desempilhamento. Lembre-
se que λλ = λ.
Lema 9: Elementos Livres-de-Contexto com valor nominal igual a 0 (ZERO). Quando o valor
nominal da variável for igual a zero, deve-se construir o autômato a pilha considerando duas
hipóteses: a primeira, de o elemento ser vazio e a segunda, deste elemento não ser vazio.
Exemplo: L = 014N01+015N0 / N ≥ 0
Q = q0, q1, q2, q3, q4, q5, q6 Q x ΣP 0 1 λ

Σ = 0, 1 q0, Z q1, Z
S0 = q0 q1, Z q2, Z q1, NNNNNZ
F = q6 q1, N q2, N q1, NNNNNN
ΣP = N, Z q2, Z q3, Z
Z0 = Z q2, N q3, N
q3, Z q4, Z q3, Z
q3, N q4, N q3, N
q4, Z q5, Z
q4, NNNN q4, λ
q5, Z q6, λ
6. TRANSFORMAÇÃO DE GRAMÁTICAS LIVRES-DE-CONTEXTO EM

AUTÔMATOS A PILHA
Sempre que duas ou mais estruturas tiverem o mesmo poder, podemos converter uma na outra. Neste
tópico, vamos demonstrar o algoritmo de conversão de gramáticas livres-de-contexto em autômatos
a pilha.
Neste algoritmo de transformação, o autômato a pilha resultante é baseado na pilha e não na

linguagem, como temos aprendido até aqui. Esta forma de descrever um autômato a pilha é bem mais
complexa, se o ponto de partida for a linguagem, porém, bem mais simples, se o ponto de partida for
a gramática.
Esta nova forma de descrever o autômato a pilha só é possível devido a possibilidade de leitura, entre
os elementos da cadeia, de elementos vazios. Por exemplo, a cadeia 01011 pode ser lida da seguinte
maneira: λ0λ1λ0λ1λ1λ sem que a informação contida da mesma seja alterada.
Para fazer a conversão, devemos seguir os seguintes passos:
1 – Transformar a gramática Livre-de-Contexto na forma normal de Greibach;
2 – Os seis elementos iniciais do autômato a pilha serão:
2.1. Q = q0, q1, q2; // Independente da linguagem, o autômato a pilha só terá três estados;
2.2. Σ = ΣG // Alfabeto do autômato a pilha é o mesmo da gramática;
59
2.3. S0 = q0; // O estado inicial do autômato a pilha será sempre q0;

2.4. F = q2; // O único estado final do autômato a pilha será sempre q2;
2.5. ΣP = Z, VG; // O alfabeto de pilha será sempre o Z e as variáveis da gramática;
2.6. Z0 = Z; // Como nas convenções;
3 – A função do autômato a pilha será formada por três partes:
3.1. δ (q0, Z, λ) = { (q1, SZ) };

3.2. As produções da gramática na forma:
∀α ∈ Σ & X, Y ∈ V temos X = αY
geram transições no autômato a pilha da seguinte forma:
δ (q1, X, α) = { (q1, Y) };
3.3. δ (q1, Z, λ) = { (q2, λ) };
Exemplo:
Passo 01:
• V= S, A, B, C, D • V= S, A, B, C, D, E, F, G
• Σ = 0, 1, 2 • Σ = 0, 1, 2
• S0 = S; • S0 = S;
• δ • δ
S = 0S0 ∪ 00A00 S = 0SE ∪ 0EAEE
A = A1 ∪ B1 A = AF ∪ BF
B = 0B ∪ 1B ∪ 2B ∪ C B = 0B ∪ 1B ∪ 2B ∪ C
C = 01C ∪ C10 ∪ 01D C = 0FC ∪ CFE ∪ 0FD
D = 01 ∪ 102 ∪ λ D = 0F ∪ 1EG ∪ λ
E = 0;
F = 1;
G = 2;
Passo 02: Passo 03:
Q = q0, q1, q2; Q x ΣP 0 1 2 λ

Σ = 0, 1, 2 q0, Z q1, SZ
S0 = q0; q1, S q1, SE
q1, EAEE
F = q2;
q1, A q1, AF
ΣP = Z, S, A, B, C, D, E, F, G q1, BF
Z0 = Z; q1, B q1, B q1, B q1, B q1, C
q1, C q1, FC q1, CFE
q1, FD
q1, D q1, F q1, EG q1, λ
q1, E q1, λ
q1, F q1, λ
q1, G q1, λ
q1, Z q2, λ
60
APOSTILA DE LINGUAGENS FORMAIS –MÁQUINAS DE TURING Prof. TENORIO
6. MÁQUINAS DE TURING
1. HISTÓRICO
A computação digital, quando surgiu, um século após Charles Babbage (26/12/1791 – 18/10/1871)
ter projetado o primeiro computador analógico da história (1837), não se mostrou através de uma
feira de informática ou em um laboratório de algum cientista famoso de alguma universidade
consagrada. A possibilidade de se construir um computador digital foi dada ao mundo através de um
inusitado artigo, em um jornal de matemática no ano de 1936. No momento, quase ninguém percebera
que a descoberta descrita naquele obscuro artigo iria conduzir a uma arrancada mundial no campo
tecnológico, embora seu jovem autor, na época com 24 anos, já estivesse na busca de uma máquina
que simulasse os processos humanos de conhecimento desde 1934.
Esse autor foi Alan Turing, que se consagrou como um dos maiores matemáticos do seu tempo
quando fez antever aos seus colegas que era possível executar operações computacionais sobre a
teoria dos números (leia-se número binários) por meio de uma máquina que tivesse embutidas as
regras de um sistema formal. Um sistema formal é uma espécie de "jogo" rigorosamente definido,
que especifica regras para manipulação de símbolos.
Apesar da maquina ser abstrata, por possui memória ilimitada, Turing usou seus conceitos para
construir uma máquina física, com o objetivo de quebrar os códigos secretos das comunicações
alemãs durante a II Guerra Mundial. Essa máquina ficou conhecida como Colossus e certamente
salvou a vida de muitos soldados ingleses durante a guerra.
Turing também é responsável por diversos conceitos que estudamos hoje na Ciência da Computação.
O Colossus
61
2. CONCEITO
As Máquinas de Turing são os autômatos mais potentes que estudaremos. Elas podem computar
qualquer função computável, ou seja, executam quaisquer instruções de um computador, por mais
moderno que ele seja.
Num sentido preciso, uma Máquina de Turing Padrão é um modelo abstrato de um computador, que
se atém apenas aos aspectos lógicos do seu funcionamento e não à sua implementação física. Uma
Máquina de Turing Padrão pode simular o funcionamento de qualquer computador digital. Entretanto,
é mais fácil explicar o que é uma Máquina de Turing Padrão apresentando-a como uma máquina
realizada fisicamente.
2.1. Conceito Informal da Máquina de Turing
Uma máquina de Turing consiste em:
• Uma fita infinita em ambas as direções (direita e esquerda), que é dividida em células, uma
adjacente à outra. Cada célula contém um símbolo de algum alfabeto finito. O alfabeto contém
um símbolo especial branco (aqui escrito como Б), um delimitador (aqui escrito como ►) e
um ou mais símbolos adicionais. Assume-se que a fita é arbitrariamente extensível para a
esquerda e para a direita, isto é, a máquina de Turing possui tanta fita quanto é necessário para
a computação. Assume-se também que células que ainda não foram escritas estão preenchidas
com o símbolo branco.
• Um cabeçote, que pode ler e escrever símbolos na fita e mover-se para a esquerda e para a
direita.
• Um operador de estados, que armazena o estado da máquina de Turing. O número de estados
diferentes é sempre finito e há um estado especial denominado estado inicial com o qual o
registrador de estado é inicializado.
• Uma tabela de ação (ou função de transição) que diz à máquina que símbolo escrever, como
mover o cabeçote ('E' para esquerda e 'D' para direita) e qual será seu novo estado, dados o
símbolo que ele acabou de ler na fita e o estado em que se encontra. Se não houver entrada
alguma na tabela para a combinação atual de símbolo e estado então a máquina pára.
Note que cada parte da máquina é finita, porém, a quantidade de fita potencialmente ilimitada é que
dá uma quantidade ilimitada de espaço de armazenamento na máquina.
62
2.2. Conceito Formal da Máquina de Turing
Formalmente falando, a Máquina de Turing é uma nôntupla, formada por:
3. CARACTERÍSTICAS DA MÁQUINA DE TURING PADRÃO
1 – A máquina de Turing tem uma fita que é ilimitada, em ambas as direções, permitindo qualquer
número de movimentos para a direita (R) ou para a esquerda (L);
2 – A máquina de Turing é determinística, no sentido de que δ define, no máximo, um movimento

para cada configuração. O mesmo conceito do autômato a pilha;
3 – Não existe fita de entrada especial. Assumimos que o início da fita tem o conteúdo especial.
Alguns destes podem ser considerados entradas. Analogicamente, não existe nenhum dispositivo de
saída. Sempre que a máquina pára, algum ou todo o conteúdo da fita pode ser visto como saída.
4. CONVENÇÕES
1) A função de produção será representa em uma tabela, cujas linhas expressam o estado atual e
as colunas, os elementos do alfabeto.
3) Existirá apenas um estado final e este não será o inicial e nem terá saída alguma;
63
5. TESE DE CHURCH-TURING
Na teoria da computação, a Tese de Church-Turing ou Tese de Church, assim nomeada em referência

ao seu criador, o professor Alonzo Church e o seu referencial, o matemático Alan Turing, é uma
hipótese sobre a natureza de artefatos mecânicos de cálculo, como computadores, e sobre que tipo de
algoritmos eles podem executar.
Geralmente assume-se que um algoritmo deve satisfazer os seguintes requisitos:
• O algoritmo consiste de um conjunto finito de instruções simples e precisas, que são descritas
com um número finito de símbolos;
• O algoritmo sempre produz resultado em um número finito de passos;
• O algoritmo pode, a princípio, ser executado por um ser humano com apenas papel e lápis;
• A execução do algoritmo não requer inteligência do ser humano além do necessário para
entender e executar as instruções;
Um exemplo de tal método é o algoritmo de Euclides para a determinação do máximo divisor comum
de dois números naturais.
A noção de algoritmo é intuitivamente clara mas não é definida formalmente, pois não está claro o
que quer dizer "instruções simples e precisas", e o que significa "inteligência necessária para executar
as instruções". Informalmente a tese enuncia que nossa noção de algoritmo pode ser formalizada (sob
a forma de funções computáveis) e que computadores podem executar esses algoritmos. Além disso,
qualquer computador pode, teoricamente, executar qualquer algoritmo, isto é, o poder computacional
teórico de cada computador é o mesmo e não é possível construir um artefato de cálculo mais
poderoso que um computador.
A tese, de acordo com as palavras do próprio Turing, pode ser enunciada como:
“Toda função que seria naturalmente considerada computável pode ser computada por uma
Máquina de Turing”
Devido à imprecisão do conceito de uma "função que seria naturalmente considerada computável", a
tese não pode ser nem provada nem refutada formalmente. Já que não pode ser matematicamente
demonstrada, a tese de Church-Turing pode ser considerada uma lei física.
A tese, em palavras de Alonzo Church, pode ser enunciada como:
“Qualquer computação que pode ser efetuada por meios mecânicos, pode ser efetuada por uma
Máquina de Turing padrão”.
Em resumo: Qualquer programa de computador pode ser traduzido em uma máquina de Turing, e
qualquer máquina de Turing pode ser traduzida para uma linguagem de programação de propósito
geral; assim, a tese é equivalente a dizer que qualquer linguagem de programação de propósito geral
é suficiente para expressar qualquer algoritmo.
64
Argumentos que validam a tese:
1.1. Qualquer algoritmo que pode ser executado em máquina existente, também pode ser
executado por uma máquina de Turing padrão;
1.2. Ninguém foi capaz de sugerir um problema solúvel, pelo o que intuitivamente entendemos
por um algoritmo, para o qual, um programa de máquina de Turing não possa ser escrito
para ele;
1.3. Têm sido propostos modelos alternativos de computação mecânica, porém, nenhum deles é
mais poderosos do que o modelo da máquina de Turing padrão;
Desde aquela época muitos outros formalismos foram propostos para descrever a computabilidade
efetiva, incluindo funções recursivas, o cálculo lambda, máquinas de registros, sistemas de Post,
lógica combinatória e algoritmos de Markov. Foi mostrado que todos esses sistemas computam
essencialmente o mesmo conjunto de funções que as máquinas de Turing; sistemas como esses são
chamados Turing completos. Como todas as diversas tentativas de formalizar o conceito de
algoritmo levaram a resultados equivalentes, geralmente assume-se que a tese de Church-Turing é
correta. No entanto, a tese é uma definição, e não um teorema, e portanto não pode ser provada. Ela
poderia, no entanto, ser refutada se alguém descobrisse um método que fosse universalmente aceito
como um algoritmo efetivo mas que não pudesse ser executado por uma máquina de Turing.
No início do século XX, matemáticos freqüentemente usaram o termo informal efetivamente

computável, então foi importante achar uma boa formalização do conceito. Matemáticos modernos
usam, em seu lugar, o termo bem-definido Turing-computável (ou apenas computável). Já que a
terminologia indefinida caiu em desuso, a questão de como defini-la é agora menos importante.
6. O PROBLEMA DA PARADA
Na teoria da computabilidade o problema da parada é um problema de decisão2 que pode ser declarado
informalmente da seguinte forma:
“Dado uma descrição de um programa e uma entrada finita, decida se o programa termina de
rodar ou rodará indefinidamente, dada essa entrada.”
Alan Turing provou em 1936 que um algoritmo genérico para resolver o problema da parada para
todos pares programa-entrada possíveis não pode existir. Dizemos que o problema da parada é
indecidível nas Máquinas de Turing.
2
Um problema de decisão é uma questão sobre um sistema formal com uma resposta do tipo sim-ou-não. Por exemplo,
o problema: "dados dois números x e y, y é divisível por x?" é um problema de decisão. Ou ainda: "Dado um número
inteiro x, x é um número primo?". A resposta para esses problemas pode ser 'sim' ou 'não', e depende dos valores que as
variáveis assumem em cada instância do problema.
65
7. CONSTRUÇÃO DA MÁQUINA DE TURING
Como já vimos, as máquinas de Turing são capazes de executar todo e qualquer algoritmo existente.
Para cada classe de algoritmo, existem formas diferentes de se construir uma máquina de Turing
padrão. Lembre-se que, construir uma máquina de Turing, significa descrever toda sua nôntupla.
A tabela da função que compõe a máquina de Turing é composta, em sua primeira linha, pelos
elementos do alfabeto de fita e em sua primeira coluna, pelos possíveis estados atuais. Cada
componente da tabela é formado pelo próximo estado, pelo elemento do alfabeto de fita que será
gravado na fita e pelo movimento da máquina.
Neste tópico, vamos estudar os dois tipos de máquinas de Turing mais importantes para a Teoria da
Computação, são eles:
7.1 – Máquinas de Turing como Reconhecedor de Linguagens
Neste caso, a função das máquinas de Turing é a validação de cadeias em uma linguagem específica,
na prática, verifica se um algoritmo está escrito de maneira correta em relação à sintaxe da linguagem
de programação.
Para as linguagens regulares, uma forma simples de se descrever a máquina de Turing é construir o
autômato finito da linguagem, conforme demonstrado no módulo 2 desta apostila. Em seguida,
montar sua nôntupla.
Dica: em linguagens regulares, o cabeçote de leitura só precisa fazer movimentos para a direita e
dificulmente precisará alterar o conteúdo da fita.
Exemplo: L = (0+1(01)+10)* ∪ 1 (0*1*)* 10*
Depois de construir o autômato finito para esta linguagem chegamos à seguinte máquina de Turing:
Q = q0, q1, q2, q3, q4, q5, q6, q7, q8, q9 ΣF 0 1 ► Б

Σ = 0, 1 Q
S0 = q0 q0 q1, 0, R q8, 1, R q0, ►, R
F = q7 q1 q1, 0, R q2, 1, R
ΣF = 0, 1, ►, Б q2 q3, 0, R
R = q0, q1, q2, q3, q4, q5, q6, q8, q9 q3 q4, 1, R
►=► q4 q3, 0, R q5, 1, R
Б=Б q5 q6, 0, R
q6 q1, 0, R q7, Б, P
q8 q8, 0, R q8, 1, R
q9, 1, R
q9 q9, 0, R q7, Б, P
Detalhamento: assim como no autômato a pilha, o elemento que está na tabela, substitui o elemento
que está na fita. Neste caso, como já foi dito, nenhum elemento da fita precisou ser alterado, devido
à linguagem ser regular.
Atenção: a máquina de Turing do exemplo é Não-Determinística, devido ao estado q8 que possui

duas saídas para o elemento 1 do alfabeto.
66
Atenção 02: Toda e qualquer máquina de Turing possui a instrução q0, ► = q0, ►, R.
Para as linguagens não-regulares é necessário garantir que a quantidade de elementos nos expoentes
variáveis esteja de acordo com o descrito na linguagem. Para que essa quantidade seja garantida é
necessário que a máquina conte essas quantidades e verifique esse valor resultante da contagem.
Uma forma de se contar elementos em uma máquina de Turing é a técnica da marcação dos valores.
Marcar significa substituir o valor, presente na máquina de Turing, por um marcador, que será um
caractere qualquer que não faça parte do alfabeto da linguagem e obrigatoriamente, faça arte do
alfabeto da fita.
Imagine verificar a quantidade de elementos presentes em dois conjuntos ‘A’ e ‘B’, sem usar os
números reais. Uma forma seria, por exemplo, pintar os elementos. Iniciamos pintando um elemento
de ‘A’ e logo em seguida, pintamos um elemento de ‘B’, ficamos nesse loop até que todos os
elementos de ‘A’ estejam pintados ou que não haja mais correspondentes em ‘B’ para serem pintados.
Daí, basta fazer as verificações:
1 – Se foi pintado um elemento em A e não existia nenhum elemento a ser pintado em B, a

quantidade de elementos de ‘A’ é maior do que os elementos de ‘B’;
2 – Se todos os elementos de ‘A’ já foram pintados e ainda existir, ao final do loop, elementos
em ‘B’ não pintados, significa que a quantidade de elementos de ‘A’ é menor do que a quantidade de
elementos de ‘B’;
3 – Se ao pintarmos o último elemento em ‘A’, também for pintado o último elemento em ‘B’,
no mesmo loop, significa que a quantidade de elementos de ‘A’ e ‘B’ são iguais.
Fazendo uma analogia deste exemplo, vamos construir uma máquina de Turing para a linguagem:
L = 0N1N / N ≥ 1
Q = q0, q1, q2, q3, q4 ΣF 0 1 X Y ► Б

Σ = 0, 1 Q
S0 = q0 q0 q1, X, R q3, Y, R q0, ►, R
F = q4 q1 q1, 0, R q2, Y, L q1, Y, R
ΣF = 0, 1, X, Y, ►, Б q2 q2, 0, L q0, X, R q2, Y, L
R = q0, q1, q2, q3 q3 q3, Y, R q4, Б, P
►=►
Б=Б
Detalhamento: Neste exemplo, fazendo uma analogia ao exemplo das pinturas de ‘A’ e ‘B’, temos
que X é a cor com que pintamos (marcamos) os elementos ‘0’ e Y é a cor com que pintamos
(marcamos) os elementos ‘1’. Portanto, se ao final da execução da máquina, sobrar elementos não
marcados na fita, significa que a cadeia não é válida e não chegará ao estado final. O passo-a-passo
da fita, com a cadeia 000111 de entrada (escolhida aleatoriamente uma cadeia não mínima) fica da
seguinte maneira:
67
... Б ► 0 0 0 1 1 1 Б Б Б ...
... Б ► X 0 0 1 1 1 Б Б Б ...
... Б ► X 0 0 Y 1 1 Б Б Б ...
... Б ► X X 0 Y 1 1 Б Б Б ...
... Б ► X X 0 Y Y 1 Б Б Б ...
... Б ► X X X Y Y 1 Б Б Б ...
... Б ► X X X Y Y Y Б Б Б ...
... Б ► X X X Y Y Y Б Б Б ...
Note que, ao final da execução, não sobrou nenhum elemento sem marcar, portanto a cadeia é válida,
como podemos constatar também na linguagem.
7.2 – Máquinas de Turing como Operador Algébrico
Neste caso, a função das máquinas de Turing é a execução de cálculos matemáticos. Esse tipo de
máquina expressa exatamente o que acontece na U.L.A. (Unidade de Lógica e Aritmética) em um
computador.
Para a construção dessas máquinas de Turing é importante definir, anteriormente, a função de cada
estado na máquina. Essa função depende do operador que está sendo usado na equação, da quantidade
de variáveis e da base dessas variáveis (binária, decimal, etc.). Nenhum estado pode acumular
funções, ou seja, cada estado terá uma única função dentro da máquina. Vamos ao exemplo 01.
X2 + 1 / X ∈ΙΝ
Note que, neste exemplo, a base de X é dois, ou seja, estamos trabalhando com a base binária
(números binários). A soma de uma unidade ao um número binário é feita da seguinte forma:
1 – Se o último elemento for 0, basta que esse elemento se transforme em 1 para obtermos o resultado.
01101000100
+1
01101000101
2 – Se o último elemento for 1, este um passa a ser 0 e verificamos o elemento logo a sua esquerda.
Esse passo é feito até que se encontre um elemento 0 para que seja aplicado a regra anterior.
01101000111
+1
01101001000
68
Com isso, verificamos as seguintes funções para cada estado.
q0 = Encontrar o último elemento da máquina; Como a maquina sempre inicia no delimitador e o que
interessa para equação é o último elemento, precisamos de um estado para fazer o cabeçote apontar
para esse último elemento.
Importante Para fazer uma máquina apontar para o último elemento da cadeia, basta mover o
cabeçote de leitura para direita até que se encontre o branco de fita (Б). Daí basta mover o cabeçote
uma única vez para a esquerda e pronto, ele estará apontando para o último elemento da cadeia.
q1 = Substituir os elementos; Nesta equação, quando o elemento for 0, esse estado vai trocar esse 0
por 1 e desligar a máquina, pois o resultado já estará pronto. Caso encontre o elemento 1, esse estado
vai substituir esse 1 por 0 e continuará sua busca por um elemento 0, para poder concluir sua
execução.
q2 = Estado Final; Todas as máquinas de Turing terão um estado, cuja única função é ser um estado
final.
Q = q0, q1, q2 ΣF 0 1 ► Б
Σ = 0, 1 Q
S0 = q0 q0 q0, 0, R q0, 1, R q0, ►, R q1, Б, L
F = q2 q1 q2, 1, P q1, 0, L
ΣF = 0, 1, ►, Б q2
R = q0, q1
►=►
Б=Б
Atenção: Nas máquinas de Turing como Operador Algébrico, o alfabeto da máquina (Σ) é exatamente
a base das variáveis. O alfabeto da fita (ΣF) pode variar bastante.
Importante Sempre que um estado conclui sua função, a máquina troca de estado.
O passo-a-passo desta máquina é descrito abaixo.
... Б ► 0 1 0 0 1 1 Б Б Б ...
... Б ► 0 1 0 0 1 1 Б Б Б ...
... Б ► 0 1 0 0 1 0 Б Б Б ...
... Б ► 0 1 0 0 0 0 Б Б Б ...
... Б ► 0 1 0 1 1 1 Б Б Б ...
... Б ► 0 1 0 1 1 1 Б Б Б ...
Para os próximos exemplos, com o objetivo de facilitar a construção das máquinas, vamos
trabalhar com a base unária.
Base unária: {1, 11, 111, 1111, 11111, 111111, 1111111, 11111111, 111111111, ...}
69
Exemplo 02: X1 + Y1 / X, Y ∈ΙΝ
Antes de definir as funções de cada estado, vamos observar a montagem da fita e o seu passo-a-passo.
Na fita, deverá existir um separador, para que possamos identificar onde termina o X e onde começa
o Y.
X e Y na fita sem o separador X e Y na fita com o separador
... Б ► 1 1 1 1 1 1 Б Б Б ... ... Б ► 1 1 1 1 + 1 1 Б Б ...
Sem o separador, é impossível definir os valores de X e de Y. Quando o separador é colocado,

verificamos que X = 4 e Y = 2. Lembramos que esses valores foram escolhidos de maneira aleatória
dentro do universo dos números naturais, pois a máquina deve executar a operação para quaisquer
valores de X e Y dentro do conjunto dos números naturais. Também foi escolhido o sinal de + como
separador apenas como uma forma ilustrativa, podendo ser utilizado qualquer símbolo que se queira.
Vejamos o passo a passo da máquina:
... Б ► 1 1 1 1 + 1 1 Б Б ...
... Б ► 1 1 1 1 + 1 1 Б Б ...
... Б ► 1 1 1 1 1 1 1 Б Б ...
... Б ► 1 1 1 1 1 1 1 Б Б ...
... Б ► 1 1 1 1 1 1 Б Б Б ...
... Б ► 1 1 1 1 1 1 Б Б Б ...
Desse passo-a-passo, podemos definir a função de cada estado da máquina.
q0 = localizar o separador e transformar o mesmo em 1;

q1 = apontar para o último elemento da cadeia;
q2 = apagar o último elemento da cadeia;
q3 = estado final.
Importante Nas máquinas de Turing como Operador Algébrico, sempre que um estado encontrar
um separador, ele deve concluir imediatamente sua função e trocar de estado.
Vamos à máquina de Turing resultado do exemplo:
Q = q0, q1, q2, q3 ΣF 1 + ► Б

Σ=1 Q
S0 = q0 q0 q0,1 , R q1, 1, R q0, ►, R
F = q3 q1 q1, 1, R q2, Б, L
ΣF = 1, +, ►, Б q2 q3, Б, P
R = q0, q1, q2 q3
►=►
Б=Б
Note, base unária, alfabeto da máquina igual a 1.
70
Exemplo 03: X1 – Y1 / X > Y & X, Y ∈ΙΝ
Neste exemplo vamos usar o sinal de – como separador. Para definir a função de cada estado, vamos
analisar o passo-a-passo da máquina:
... Б ► 1 1 1 1 – 1 1 Б Б ...
... Б ► 1 1 1 1 – Y 1 Б Б ...
... Б ► 1 1 1 X – Y 1 Б Б ...
... Б ► 1 1 1 X – Y Y Б Б ...
... Б ► 1 1 X X – Y Y Б Б ...
... Б ► 1 1 Б Б Б Б Б Б Б ...
Com esse passo-a-passo, definimos as funções de cada estado.
q0 = Localiza o separador; a primeira função da máquina é substituir o primeiro 1 depois do separador

por Y, porém está não pode ser a função do q0, pois, como já foi dito, ao encontrar um separador a
máquina deve trocar de estado (Lema 3).
q1 = Trocar um elemento 1 depois do separador, por Y;

q2 = Localizar o separador;
q3 = Trocar um elemento 1 antes do separador, por X;
q4 = Substituir tudo que não for elemento 1 por branco de fita (Б);
q5 = Estado final;
Eis a máquina de Turing:
Q = q0, q1, q2, q3, q4, q5 ΣF 1 – X Y ► Б

Σ=1 Q
S0 = q0 q0 q0, 1, R q1, –, R q0, X, R q0, ►, R
F = q5 q1 q2, Y, L q1, Y, R q4, Б, L
ΣF = 1, –, X, Y, ►, Б q2 q3, –, L q2, Y, L
R = q0, q1, q2, q3, q4 q3 q0, X, R q3, X, L
►=► q4 q5, 1, P q4, Б, L q4, Б, L q4, Б, L
Б=Б q5
71
Exemplo 04: 2 X1 / X ∈ΙΝ
Neste exemplo, não precisaremos do separador, pois só existe uma variável a ser executada. Lembre-
se que qualquer máquina de Turing pode ser construída de maneiras diferentes. Nesta apostila, estou
mostrando exemplos da maneira que julgo ser mais fácil para o aprendizado dos alunos. Vamos ao
passo-a-passo:
... Б ► 1 1 1 1 Б Б Б Б Б ...
... Б ► X X X X Б Б Б Б Б ...
... Б ► X X X 1 Б Б Б Б Б ...
... Б ► X X X 1 1 Б Б Б Б ...
... Б ► X X 1 1 1 Б Б Б Б ...
... Б ► X X 1 1 1 1 Б Б Б ...
... Б ► X 1 1 1 1 1 Б Б Б ...
... Б ► X 1 1 1 1 1 1 Б Б ...
... Б ► 1 1 1 1 1 1 1 Б Б ...
... Б ► 1 1 1 1 1 1 1 1 Б ...
... Б ► 1 1 1 1 1 1 1 1 Б ...
q0 = transformar todos os elementos 1 da fita em X;

q1 = transformar um X em 1;
q2 = acrescentar um no final;
q3 = estado final.
Eis a máquina de Turing:
Q = q0, q1, q2, q3 ΣF 1 X ► Б

Σ=1 Q
S0 = q0 q0 q0, X, R q0, ►, R q1, Б, L
F = q3 q1 q1, 1, L q2, 1, R q3, ►, P
ΣF = 1, X, ►, Б q2 q2, 1, R q1, 1, L
R = q0, q1, q2 q3
►=►
Б=Б
72
Exemplo 05: 3 X1 + 2 / X ∈ΙΝ
Neste caso, vale a precedência de operadores, ou seja, primeiro realizamos a multiplicação e somente
após a conclusão desta multiplicação, realizaremos a soma. Mais uma vez, não precisaremos de
separador, pois existe apenas uma variável a ser processada. Vamos ao passo-a-passo:
... Б ► 1 1 Б Б Б Б Б Б Б ...
... Б ► X X Б Б Б Б Б Б Б ...
... Б ► X 1 Б Б Б Б Б Б Б ...
... Б ► X 1 1 Б Б Б Б Б Б ...
... Б ► X 1 1 1 Б Б Б Б Б ...
... Б ► 1 1 1 1 Б Б Б Б Б ...
... Б ► 1 1 1 1 1 Б Б Б Б ...
... Б ► 1 1 1 1 1 1 Б Б Б ...
... Б ► 1 1 1 1 1 1 Б Б Б ...
... Б ► 1 1 1 1 1 1 1 Б Б ...
... Б ► 1 1 1 1 1 1 1 1 Б ...
... Б ► 1 1 1 1 1 1 1 1 Б ...

q6 = estado final;
Importante Nas multiplicações, deve-se acrescentar ‘1s’ (uns) no final da fita. A quantidade de
uns é exatamente igual ao coeficiente de X – 1.
Importante Para acrescentar ‘1s’ no final da fita, deve-se saber a quantidade exata destes ‘1s’ e
declarar um estado para cada ‘1’ que se quer colocar, ou seja, caso queira colocar quatro ‘1s’ no final
da fita, deve declarar quatro estados diferentes para realizar esta tarefa, um estado para cada ‘1’ a ser
acrescentado.
Detalhamento: Os estados q0 e q1 possuem as mesmas funções do exemplo anterior, isto por que se
trata de uma multiplicação e a regra pode ser aplicada a todos os casos semelhantes. Como o
coeficiente de X é 3, devemos acrescentar dois elementos no final a fita (Lema 4), para isto
utilizaremos os estados q2 e q3 (Lema 5). Os estados q4 e q5 resolvem a soma da equação (neste
exemplo a soma é de dois elementos) acrescentando dois ‘1s’ no final da fita. Essa soma será iniciada
quando a multiplicação estiver resolvida, ou seja, quando o q1 encontrar o delimitador.
73
Vamos à máquina de Turing do exemplo 5, baseando-se nas funções de cada estado:
Q = q0, q1, q2, q3, q4, q5, q6 ΣF 1 X ► Б

Σ=1 Q
S0 = q0 q0 q0, X, R q0, ►, R q1, Б, L
F = q6 q1 q1, 1, L q2, 1, R q4, ►, R
ΣF = 1, X, ►, Б q2 q2, 1, R q3, 1, R
R = q0, q1, q2, q3, q4, q5 q3 q1, 1, L
►=► q4 q4, 1, R q5, 1, R
Б=Б q5 q6, 1, P
q6
Exemplo 06: 5 X1 – 3 / X > 0 & X ∈ΙΝ
Este exemplo é bastante similar ao anterior. Vamos verificar esta afirmação comparando a função de
cada estado de ambos os exemplos, mas antes, vamos verificar o passo-a-passo da máquina:
... Б ► 1 1 Б Б Б Б Б Б Б Б Б ...
... Б ► X X Б Б Б Б Б Б Б Б Б ...
... Б ► X 1 Б Б Б Б Б Б Б Б Б ...
... Б ► X 1 1 Б Б Б Б Б Б Б Б ...
... Б ► X 1 1 1 Б Б Б Б Б Б Б ...
... Б ► X 1 1 1 1 Б Б Б Б Б Б ...
... Б ► X 1 1 1 1 1 Б Б Б Б Б ...
... Б ► 1 1 1 1 1 1 Б Б Б Б Б ...
... Б ► 1 1 1 1 1 1 1 Б Б Б Б ...
... Б ► 1 1 1 1 1 1 1 1 Б Б Б ...
... Б ► 1 1 1 1 1 1 1 1 1 Б Б ...
... Б ► 1 1 1 1 1 1 1 1 1 1 Б ...
... Б ► 1 1 1 1 1 1 1 1 1 1 Б ...
... Б ► 1 1 1 1 1 1 1 1 1 Б Б ...
... Б ► 1 1 1 1 1 1 1 1 Б Б Б ...
... Б ► 1 1 1 1 1 1 1 Б Б Б Б ...
... Б ► 1 1 1 1 1 1 1 Б Б Б Б ...
74
Com base neste passo-a-passo, podemos definir a função de cada estado da máquina.

q6 = aponta para o último elemento da fita;
q7 = elimina o último 1 da fita;
q10 = estado final;
Importante Para eliminar o último elemento, primeiro devemos localizá-lo e somente depois
eliminá-lo. Neste caso, usa-se um estado apenas para localizar e outro para eliminar. Um único estado
NÃO pode localizar e eliminar o último elemento ao mesmo tempo.
Importante Para subtrair ‘1s’ no final da fita, deve-se saber a quantidade exata destes ‘1s’ e
declarar um estado para cada ‘1’ que se quer eliminar, ou seja, caso queira eliminar quatro ‘1s’ no
final da fita, deve declarar quatro estados diferentes para realizar esta tarefa, um estado para cada ‘1’
a ser apagado. Este último lema é semelhante ao lema 5.
Detalhamento: Os estados q0 e q1 possuem as mesmas funções do exemplo anterior, isto por que se
trata de uma multiplicação e a regra pode ser aplicada a todos os casos semelhantes. Como o
coeficiente de X é 5, devemos acrescentar quatro elementos no final a fita (Lema 4), para isto serão
utilizados os estados q2, q3, q4 e q5 (Lema 5). O estado q6, serve apenas para localizar o último ‘1’
da fita (Lema 6) e os estados posteriores irão eliminar a quantidade de ‘1s’ necessária, neste exemplo
serão três elementos (– 3 da equação), portanto precisaremos dos estados q7, q8 e q9 (Lema 7). Vamos
à máquina de Turing deste exemplo, baseando-se nas funções de cada estado:
Q = q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, q10 ΣF 1 X ► Б
Σ=1 Q
S0 = q0 q0 q0, X, R q0, ►, R q1, Б, L
F = q10 q1 q1, 1, L q2, 1, R q6, ►, R
ΣF = 1, X, ►, Б q2 q2, 1, R q3, 1, R
R = q0, q1, q2, q3, q4, q5, q6, q7, q8, q9 q3 q4, 1, R
►=► q4 q5, 1, R
Б=Б q5 q1, 1, L
q6 q6, 1, R q7, Б, L
q7 q8, Б, L
q8 q9, Б, L
q9 q10, Б, P
q10
75
8. VARIAÇÕES DA MÁQUINA DE TURING PADRÃO
Com o objetivo de aumentar a velocidade das Máquinas de Turing, algumas variações em sua
construção podem ser propostas. Vejamos as mais comuns:
8.1. Máquina de Turing com opção de permanência: Nesta variação, a máquina de Turing passa a
ter os seguintes movimentos: Direita (R), Esquerda (L), Parada (P) e Imobilidade (S), em relação ao
cabeçote de leitura, sendo que o ‘S’, representa uma mudança de estado e/ou gravação de elementos
na fita, sem a necessidade de movimentar o cabeçote ou finalizar a execução da máquina;
8.2. Máquina de Turing com fita semi-infinita: Neste caso, a fita, que é ilimitada em ambas as
direções na máquina de Turing padrão, passa a ter uma fita ilimitada somente à direita e a primeira
posição é o delimitado. Note que não houve redução no tamanho da fita;
8.3. Máquina de Turing Off-line: É uma Máquina de Turing com duas fitas, sendo uma fita de
entrada, onde fica a cadeia a ser testada, e onde a informação não pode ser alterada e a outra fita
onde são gravadas as modificações e a saída da execução da máquina;
76
8.4 Máquinas de Turing com fitas Múltiplas: É a máquina composta por duas ou mais fitas. Cada
fita possui seu próprio cabeçote de leitura, porém, todos os cabeçotes estão ligados a um mesmo
operador de estados (unidade de controle);
8.5. Máquinas de Turing Multidimensional (3D): É uma máquina que possui um único cabeçote
de leitura, ligado a um único operador de estados, com uma única fita, porém, a fita é infinita em
todas as direções 3D, ou seja, é ilimitada para a esquerda, para a direita, para cima, para baixo, para
frente e para trás, sendo que o cabeçote possui todos estes movimentos de máquina (R, L, U, D, F,
A);
8.6. Máquinas de Turing Não-Determinísticas: É a máquina de Turing, que em algum momento, a

função Q x ΣF resulta em dois ou mais trios Q x ΣF x MM;
8.7. Máquina de Turing Mista: É a máquina de Turing, composta por duas ou mais variações da
máquina de Turing padrão;
Atenção: Nenhuma variação da Máquina de Turing padrão aumenta o PODER da máquina, apenas
aumenta sua velocidade;
77
9. MÁQUINA DE TURING UNIVERSAL
Toda Máquina de Turing processa uma certa função computável parcial a partir de uma cadeia
formada pelos símbolos do alfabeto. Neste sentido, ela se comporta como um computador com um
programa fixo. No entanto, como Alan Turing descreveu, podemos codificar a função de transição de
qualquer máquina de Turing em uma cadeia de símbolos, como veremos no último tópico deste
capítulo. Portanto, podemos tentar construir uma máquina de Turing que espera em sua fita uma
cadeia descrevendo a funções de transição seguida por uma cadeia descrevendo a fita de entrada, e
então computa a fita que a máquina de Turing codificada teria computado.
Como Turing mostrou, tal máquina de Turing é de fato possível e, como é capaz de simular outras
máquinas de Turing, ela é chamada de máquina de Turing universal.
Com essa codificação de funções de transição como cadeias, torna-se possível, a princípio, que
máquinas de Turing respondam questões sobre o comportamento de outras máquinas de Turing.
Muitas dessas questões, no entanto, são indecidíveis, o que significa que a função em questão não
pode ser calculada por nenhuma máquina de Turing. Por exemplo, Turing mostrou em seu artigo
original que o problema de determinar se uma máquina de Turing em particular vai parar para uma
entrada dada (ou para qualquer entrada), conhecido como Problema da parada, é indecidível. O
teorema de Rice mostra que qualquer questão não-trivial sobre o comportamento ou saída de uma
máquina de Turing é indecidível.
Se expandirmos a definição para incluir qualquer máquina de Turing que simule algum modelo
computacional Turing-completo (e não apenas máquinas de Turing que simulam diretamente outras
máquinas de Turing), então uma máquina de Turing universal pode ser bem simples, usando apenas
alguns estados e alguns símbolos. Por exemplo, apenas 2 estados são necessários, uma vez que uma
máquina universal 2×18 (com 2 estados e 18 símbolos) é conhecida. Uma lista completa das menores
máquinas de Turing universais conhecidas é: 2×18, 3×10, 4×6, 5×5, 7×4, 10×3, 22×2. Elas simulam
um modelo computacional chamado tag systems.
Uma máquina de Turing universal é Turing-completa. Ela pode calcular qualquer função recursiva,
decidir qualquer linguagem recursiva e aceitar qualquer linguagem enumeravelmente recursiva. De
acordo com a tese de Church-Turing, os problemas solucionáveis por uma máquina de Turing
universal são exatamente aqueles problemas solucionáveis por um algoritmo ou um procedimento
efetivo de computação, para qualquer definição razoável destes termos.
Em resumo, uma Máquina de Turing Universal é a máquina de Turing reprogramável, ou seja, é a

Máquina de Turing que gera Máquinas de Turing. A nôntupla da Máquina de Turing Universal é
definida por:
Q = q0, q1, q2, ..., qn

Σ = ASC II
S0 = q0
F = qn
R = q0, q1, ..., q(n-1)
ΣF = ASC II
Delimitador = ►
Branco de Fita = Б
δ = esquema a seguir:
78
10. BINARIZAÇÃO DAS MÁQUINAS DE TURING
Como vimos anteriormente, qualquer computação realizada pelas máquinas mais modernas, pode ser
processada por uma Máquina de Turing padrão. Vejamos agora, como converter uma Máquina de
Turing padrão em uma sequência de números binários, provando definitivamente, que qualquer
algoritmo nada mais é do que uma sequência binária (energia sim – energia não) dentro do hardware.
Para que possamos realizar essa tarefa, vamos seguir os seguintes passos:
1 – Completar os espaços vazios da máquina com paradas em um estado não-final (vamos

convencionar que esse estado não-final sempre será o q0);
2 – Criar a legenda da seguinte maneira:
2.1 – Estados:
q0 = 0
q1 = 10
q2 = 110
q3 = 1110
q4 = 11110
q5 = 111110
...
qn = n-uns // 0
2.2 – Alfabeto de Fita:

ΣF1 = 0
ΣF2 = 10
ΣF3 = 1110
ΣF4 = 11110
ΣF5 = 111110
ΣF6 = 1111110
2.3 – Movimentos da máquina (esses elementos são sempre padronizados):

R = 110
L = 1110
P = 11110
3 – Escrever a quantidade de estados e de alfabeto de fita, em binário, usando a mesma quantidade

de bits, tanto quanto forem necessários, sempre múltiplos de 2;
4 – Converter os comandos da máquina, em binário, usando a legenda, iniciando pela primeira coluna.
79
Para um melhor entendimento, vamos a um exemplo. Binarizar a máquina de Turing abaixo:
Q = q0, q1, q2 ΣF 0 1 ► Б
Σ = 0, 1 Q
S0 = q0 q0 q0, 0, R q0, 1, R q0, ►, R q1, Б, L
F = q2 q1 q2, 1, P q1, 0, L
ΣF = 0, 1, ►, Б q2
R = q0, q1
►=►
Б=Б
Passo 1:
Q = q0, q1, q2 ΣF 0 1 ► Б
Σ = 0, 1 Q
S0 = q0 q0 q0, 0, R q0, 1, R q0, ►, R q1, Б, L
F = q2 q1 q2, 1, P q1, 0, L q0, ►, P q0, Б, P
ΣF = 0, 1, ►, Б q2 q0, 0, P q0, 1, P q0, ►, P q0, Б, P
R = q0, q1
►=►
Б=Б
Passo 2:
Estados: Alfabeto de Fita Movimentos da Máquina:
q0 = 0 0=0 R = 110
q1 = 10 1 = 10 L = 1110
q2 = 110 ► = 110 P = 11110
Б = 1110
Passo 3: Existem três estados e quatro alfabetos de fita, em binário de 8 bits, esses números (3 e 4)
ficam assim:
00000011 e 00000100
Passo 4:
00110 1101011110 0011110 010110 1001110 01011110 0110110 011011110 011011110

1011101110 0111011110 0111011110
Resultado final:
00000011000001000011011010111100011110010110100111001011110011011001101111001101
1110101110111001110111100111011110
Atenção: Note que, se desconsiderarmos os elementos iniciais que representam a quantidade de

estados e de alfabetos de fita, cada comando da máquina é limitado por uma sequência de três zeros.
E assim, terminamos todo o conteúdo programado para a disciplina.

Aprendeu? Se a resposta for sim, você está de parabéns. Se a resposta for não: Que Pena!
◄►
80
APOSTILA DE LINGUAGENS FORMAIS – APÊNDICES Prof. TENORIO
REFERÊNCIAS
Livros:
ACIÓLY, Benedito Melo e BEDREGAL, Benjamín René Callejas. Notas de Aula de Teoria da
Computação. UFRN – DIMAP, 1999.
DIVERIO, Tiarajú Asmuz e MENEZES, Paulo Blauth. Teoria da Computação. Sagra Luzzatto,
Porto alegre, 2000.
HOPCROFT John E.; MOTWANI, Rajeev e ULLMAN Jeffrey D. Introdução à Teoria dos
Autômatos, Linguagens e Computação. Campus, São Paulo, 2002.
MENEZES, Paulo Blauth. Linguagens Formais e Autômatos. Sagra Luzzatto, Porto alegre, 2002.
PAPADIMITRIOU, Christos H. e LEWIS Harry R. Elementos da Teoria da Computação.

Bookman, Porto Alegre, 2000.
PENROSE, Roger. A Nova Mente do Rei: Computadores, Mentes e as Leis da Física. Campus,
Rio de Janeiro, 1993.
RAMOS, Marcus Vinícius Midena; JOSÉ NETO, João e VEGA, Ítalo Santiago. Linguagens
Formais. Bookman, Porto Alegre, 2009.
Apostilas de professores:
UNICAP – Universidade Católica de Pernambuco

Prof. Wilson Rosa de Oliveira Junior
Site importante: Software da disciplina: http://www.din.uem.br/yandre/sctmf/
81
ANEXOS
1. TABELA ASCII
Cód Caractere Cód Caractere Cód Caractere

SOH (Start of Heading STX (Start of TeXt /
0 NULL (nulo) 1 2
/ Início de cabeçalho) Início de Texto)
EOT (End Of
ETX (End of TeXt / ENQ (ENQuiry /
3 4 Transmission / fim de 5
fim de texto) inquirição, consulta)
transmissão)
ACK (ACKnowledge
BEL (BELL, BEEP / BS (Backspace / retorno
6 / confirmação, 7 8
Campainha) de 1 caractere)
entendido)
HT (Horizontal Tab / LF (Line Feed /
VT (Vertical Tab /
9 Tabulação 10 alimentação, mudança 11
Tabulação vertical)
horizontal) de linha)
FF (Form Feed / CR (Carriage Return / SO (Serial Out / Saída
12 Alimentação de 13 retorno ao inicio da 14 Serial) (Shift Out /
formulário) linha) deslocamento para fora)
SI (Serial In /
DLE (Data Link DC1/XON (Device
Entrada Serial) (Shift
15 16 Escape / escape de 17 Control1/controle de
In / deslocamento
conexão) dispositivo1)
para dentro)
DC2 (Device Control DC3/XOFF (Device
DC4 (Device Control 4 /
18 2 / controle de 19 Control3/controle de 20
controle de dispositivo4)
dispositivo2) dispositivo3)
NAK (Negative
ETB (End Transm.
AcKnowledge / SYN (SYNchronous
21 22 23 Block/bloco de fim de
confirmação Idle / espera síncrona)
transmissão)
negativa)
EM (End of Media /
CAN (Cancel / SUB (SUBstitute,
24 25 Fim do meio ou 26
cancelamento) substituir)
mídia)
ESC (ESCape / FS (File Separator / GS (Group Separator /
27 28 29
escape) Separador de arquivo) separador de grupo)
RS (Request to Send,
Record Separator /
US (Unit Separator /
30 requisição de envio, 31
separador de unidade)
separador de
registro)
82
Cód Carac Cód Carac Cód Carac Cód Carac Cód Carac Cód Carac
32 <espaço> 33 ! 34 " 35 # 36 $ 37 %
38 & 39 ' 40 ( 41 ) 42 * 43 +
44 , 45 - 46 . 47 / 48 0 49 1
50 2 51 3 52 4 53 5 54 6 55 7
56 8 57 9 58 : 59 ; 60 < 61 =
62 > 63 ? 64 @ 65 A 66 B 67 C
68 D 69 E 70 F 71 G 72 H 73 I
74 J 75 K 76 L 77 M 78 N 79 O
80 P 81 Q 82 R 83 S 84 T 85 U
86 V 87 W 88 X 89 Y 90 Z 91 [
92 \ 93 ] 94 ^ 95 _ 96 ` 97 a
98 b 99 c 100 d 101 e 102 f 103 g
104 h 105 i 106 j 107 k 108 L 109 m
110 n 111 o 112 p 113 q 114 R 115 s
116 t 117 u 118 V 119 w 120 X 121 y
122 z 123 { 124 | 125 } 126 ~ 127 <delete>
128 Ç 129 ü 130 é 131 â 132 ä 133 à
134 å 135 ç 136 ê 137 ë 138 è 139 ï
140 î 141 ì 142 Ä 143 Å 144 É 145 æ
146 Æ 147 ô 148 ö 149 ò 150 û 151 ù
152 ÿ 153 Ö 154 Ü 155 ø 156 £ 157 Ø
158 × 159 ƒ 160 á 161 í 162 ó 163 ú
164 ñ 165 Ñ 166 ª 167 ° 168 ¿ 169 ®
170 ┐ 171 ½ 172 ¼ 173 ¡ 174 « 175 »
176 ░ 177 ▒ 178 ▓ 179 │ 180 ┤ 181 Á
182 Â 183 À 184 © 185 ╣ 186 ║ 187 ╗
188 ╝ 189 ¢ 190 ¥ 191 ┐ 192 └ 193 ┴
194 ┬ 195 ├ 196 ─ 197 ┼ 198 ã 199 Ã
200 ╚ 201 ╔ 202 ╩ 203 ╦ 204 ╠ 205 ═
206 ╬ 207 ¤ 208 δ 209 Ð 210 Ê 211 Ë
212 È 213 ¬ 214 Í 215 Î 216 Ï 217 ┘
218 ┌ 219 █ 220 ▄ 221 ¦ 222 Ì 223 ▀
224 Ó 225 β 226 Ô 227 Ò 228 õ 229 Õ
230 Μ 231 Þ 232 þ 233 Ú 234 Û 235 Ù
236 ý 237 Ý 238 ¯ 239 ´ 240 - 241 ±
242 ≡ 243 ¾ 244 ¶ 245 § 246 ÷ 247 ,
248 º 249 “ 250 . 251 ¹ 252 ³ 253 ²
254 ■ 255
83
2. OS MESTRES
Quem são os maiores contribuintes para a formulação da Teoria da Computação? Eis a resposta.
Alan Mathison Turing Alonzo Church Sheila A. Greibach John Backus

23/06/1912 – 07/06/1954 14/06/1903 – 08/11/1995 ? / ? / 1939 31/12/1924 – 17/03/2007
John Edward Hopcroft Peter Naur Avram Noam Chomsky Stephen Cole Kleene
07/10/1939 25/10/1928 07/12/1928 05/01/1909 – 25/01/1994
Andrei Andreyevich Markov David Hilbert Emil Leon Post Kurt Friedrich Gödel
04/05/1821 – 26/11/1894 23/01/1862 – 14/02/1943 11/02/1897 – 21/04/1954 28/04/1906 – 14/01/1978
84
John von Neumann Jacques Herbrand Euclides de Alexandria Charles Babbage

28/12/1903 – 08/02/ 1957 12/02/1908 – 27/07/1931 360 a.C. — 295 a.C 26/12/1791 – 18/10/1871
Augusta Ada King Pãnini

(Condessa de Lovelace) (de Gandhara)
10/12/1815 – 27/11/1852 520 a.C – 460 a.C
Quais alunos da disciplina vão completar esta página?
85
APÊNDICE 01: ALGORITMO SOBRE AUTÔMATOS FINITOS

O aluno deve fazer um programa que leia um autômato (sua quíntupla) a partir de um arquivo texto
e possibilite ao usuário fornecer entradas a esse autômato de maneira que o programa informe se a
cadeia de entrada é aceita ou não. O arquivo texto com um autômato qualquer será levado pelo
professor e deverá ser utilizado pelo programa. O programa NÃO deve ter um autômato em seu
algoritmo, já que o mesmo será lido a partir do arquivo. ATENÇÃO: O VAZIO DEVE SER
CONSIDERADO PELO SEU PROGRAMA.
Documentos a serem entregues:

1. Código Fonte;
2. Arquivo Executável;
3. Folha com o nome da equipe e linguagem de programação utilizada;
4. Compilador utilizado;
Avaliação:
- Apresentação (Resposta precisa, rápida e correta): 3,0 Pontos
- Corretude: 2,0 Pontos
- Exercícios entregues: 1,0 Ponto
Desenvolvimento do Trabalho:
Linha 1: Quantidade de Estados (Máximo de 9)

Linha 2: Alfabeto (Máximo de 2)
Linha 3: Estado Inicial
Linha 4: Estados Finais (Máximo de 9)
Linha 5: Função no formato:
Estado_de_Origem Alfabeto Estado_de_Destino
O exemplo abaixo é de um autômato que aceita todas as cadeias que iniciem em 10:
4
01
0
2
003
011
102
113
202
212
303
313
86
APÊNDICE 02: ALGORITMOS SOBRE MÁQUINAS DE TURING
O aluno deve fazer um programa que leia um número binário a partir de um arquivo texto.
Transforme este número binário em uma Máquina de Turing seguindo as regras de conversão e
execute a Máquina de Turing mediante entradas digitadas pelo usuário do software durante sua
execução. O arquivo texto com um número binário qualquer será levado pelo professor e deverá
ser utilizado pelo programa. O programa NÃO deve ter uma Máquina de Turing em seu algoritmo,
já que o mesmo será gerado a partir do número binário lido do arquivo. ATENÇÃO: A FITA
BRANCA DEVE SER CONSIDERADA PELO SEU PROJETO.
Documentos a serem entregues:

1. Código Fonte;
2. Arquivo Executável;
3. Folha com o nome da equipe e linguagem de programação utilizada;
4. Compilador utilizado: (apenas caso o aluno não utilize os compiladores constantes neste
site).
Avaliação:
- Apresentação (Resposta precisa, rápida e correta): 3,0 Pontos
- Corretude: 2,0 Pontos
- Exercícios entregues: 1,0 Ponto
Exemplo de arquivo:
00011001000011011010111100011110010110100111001011110011011001101111001101111010
1110111001110111100111011110
ALGORITMO DA MÁQUINA DE TURING
Type
R register:
Est : integer; {Estados}
Alf : integer; {Alfabeto da fita}
MM: char; {Movimentos da Máquina}
End;
Ind : integer; {Valiável índice do bit do arquivo}

Valor: string {Valores em binário}
Val: integer; {Valores em Decimal}
Qtdest: integer; {Quantidade de estados}
Qtdalf: integer; {Quantidade de elementos do alfabeto da fita}
I,j : integer; aux: char {Variáveis Auxiliares}
Função : array [15,15] of R;
Fita: Array [100] of byte; {Representação da fita}
Pos: integer: {Posição da fita}
87
Estatual, alfatual, mmatual {Valores atuais da máquina de Turing}

Estfinal; {Estado final}
Function lerum; {Função que lê um único bit do arquivo e aponta ao próximo}

Function bindec (binário); {Função que converte um binário em decimal}
Function BinEst; {Função que converte o binário em um estado – use CASE}
Function BinAlf; {Função que converte o binário em um alfabeto da fita – use CASE}
Function BinMM; {Função que converte o binário num movimento da máquina: R,L,P}
Function inifita; {Função que inicializa a fita}
Begin
Abrir Arquivo;
Valor := “”; {Calcula a quantidade de estados}

For i:= 1 to 4 do
Begin
Valor := Concat (Valor, lerum);
End;
Qtdest := bindec (valor);
Valor := “”; {Calcula a quantidade do Alfabeto da fita}

For i:= 1 to 4 do
Begin
Valor := Concat (Valor, lerum);
End;
Qtdalf := bindec (valor);
For I := 0 to Qtdest – 1 do
For j := 0 to Qtdalf – 1 do
Begin
Valor := ‘’;
Repeat
Aux := lerum;
Valor := Concat (Valor, Aux)
Until Aux = 0;
Função [i,j].est := BinEst (valor);
Valor := ‘’;
Repeat
Aux := lerum;
Until Aux = 0;
Função [i,j].alf := BinAlf (valor);
88
Valor := ‘’;
Repeat
Aux := lerum;
Until Aux = 0;
Função [i,j].mm := Binmm (valor);
End;
End;
Inifita;
Write (‘Digite a fita:’);
Readln (FITA);
Estatual := 0;
AlfAtual := Delimitador;
Mmatual := R;
Pos := 1;
While mmatual <> ‘P’ do

Begin
Alfatual := função [EstAtual, FITA[pos]].alf;

Mmatual := função [EstAtual, FITA[pos]].mm;
EstAtual := funcao [EstAtual, FITA[pos]].est;
Fita (pos) := AlfAtual; {Atualização da Fita}
Case mmatual of
‘R’: Pos := pos +1;
‘L’: Pos := pos – 1;
End;
EstFinal := Qtdest – 1;
Write (FITA); { CUIDADO}
If EstAtual = EstFinal then

Write (‘Fita Válida’)
Else
Write (‘Fita Inválida’);
End;
End.
89
APÊNDICE 03: BINÁRIO REDUZIDO DA MÁQUINA DE TURING

UNIVERSAL
10000000010111010011010001001010101101000110100010100000110101001101000101
01001011010000110100010100101011010010011101001010010010111010100011101010
10010010101110101010011010001010001010110100000110100100000101011010001001
11010010100001010111010010001110100101010000101110100101001101000010000111
01010000111010100001001001110100010101010010101010111010000100111010010101
01010101011101000010101011101000010100010111010001010011010010000101001101
00101001001101001000101101010001011101001001010111010010100011101010010100
10011101010101000011010010101010111010100100010110101000010110101000100110
10101010100010110100101010010010110101001001011101010100101011101010010100
11010101000011101000100100101011101010100101011101010100000111010100100000
11010101010010111010100101011010001001000111010000000111010010100101010101
11010010100100101011101000001010111010000100011101000001010100111010000101
00111010000010001011101000100001110100001001010011101000100001011010001010
01011101000101001011010010000010110100010101001001101000101010101110100100
00011101001001010101011101010101001101001000101011010010010010110100000001
01101000001000110100000100101101000000000110100101000101110100101010001101
00101001010110100000100111010010101001011010010011101010000001010111010100
00001101010100010101011010010101011010100001010111010100100101011101010001
00101101010010000101110100000011101010010001011010100101001101010100010111
01010010100101110101010000010111010101000001011101000000101010101000010101
11010010101011010101000010111010100010101011101010100100101110101010100001
11010100000001110100100100001101001001000101101010101010011101000000001011
01001000011010101010100101110100100001101001000101010111010000100011101000
10000111010000110100000001011010000010010111010101001010101101000100010010
11101000001001110101010011010000010101011010000100001110100100001000111010
10101010100111010000100100111010001001000011101000010100101101000010100001
11010101010101011101000100100110100010010011010100101001011101110100010101
11010000000111010001001001011101001101001001000010110101010100110100010100
01011101000011010100001000101101010011010101001010010110101010011010010010
10111010011010010000010110100010101010001110100100001010110100000010011010
01000100101110100100001101010000010010111010010010100110100100101010110100
11010010010100101101001101001010000010110100100000111010100100110101010100
00101110100101000010111010010101010111010100010010110100100111010010101000
10111010001001110101000010110100100111010010101010101110100100011101001010
10100101110100100011101010000010101011100110101000001011010010011101010000
00101110100101101010000010101101001010010111010100001001011101000011010100
01000010110101001101010001000101101010101001011101010001010010110100010101
01011101001000010101101010001011101010010010101011101010100100101110101000
11101010001110101001001001011101010001110101001010001011101010001011101010
00010010111010100011101000101000101110100101001011101010010101001011101001
01010101010110101000010101010110100001001110100001010101010111010101000101
90
01110101010001010111010000001110101010001001011101000000111010101001000101
11010100000011010100001011010000001110100100000010111010100011101010010001
01011101010011010101010001010110100000110101010100101010110100000010011010
10101001001110101001101010101001001011010100110100100100111010000011010101
01010010101101010001001101000101001010101110100000110101010101010010110100
01000111010001010101010101101000100011101000010101110100010010000111010011
01000000010011101000000100101110100010001010011101000000100101110100101010
10100101101000010101010111010001001010010111010000010001011101010100101101
00010001001110100000100101011101000000101010110100001000111001111010000100
00011101000010010011101000001010010111010000010100101101000010001010111010
00010001001101000100001110101111010000100100101110100001001001011101000000
01010111010000101010001101000100101110100001000001110100001001110100010000
01011101010100101101000100000101110100001010101011101000000101010111010001
00001010111010001000010101110100100000111010100100100110100000010101110100
01000100101110101010000111010100101011010010101010000110100000101001110100
00001110100000100100111010010110100100010100101101010100110100010100100101
10101010011010001010100010110011010100100101110101010011010001010101010110
01101011001010101100110100100010101010111010001000111010010010101010101101
00101001010001101001000000101110100000110101010010101010110100101010100100
10001000101110100010101011010100000101011010001000001101001000101011010000
10011101010010101010101110100101101001001000101011001101001001001010101110
10011010010010010101101001011010010010010010110100101101001001010001011001
10100100101001010111010001010111010010010111001101001001010100101110011010
01010001010101110100010001110100001010010110100101000101110100101000101011
01000100111010010100010010111010001001110100101001000101110011010010001000
11101000100111010010100101010111001101001010000011100110101010101011010000
00011101001010100101010111010010001110100101010010101110011010000101001001
10011010100000110100000001110100101010100101011100110101000100001101000000
01110100010010101010111010001000111010101010101010101101000010011101001000
10010101110100101010001001101010000000101101001001110101000010101110100100
00110101000000010110100100011101010010010111010000110101000010101011010100
01011101010000101001011101010001011101010001010101011100110101000101011010
0001101010001001010
91

Apostila de Linguagens Formais 4.0

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Apostila de Linguagens Formais 4.0

Încărcat de

Drepturi de autor:

Formate disponibile

AUTARQUIA EDUCACIONAL DO VALE DO SÃO FRANCISCO – AEVSF

FACULDADE DE CIÊNCIAS APLICADAS E SOCIAIS DE PETROLINA – FACAPE

APOSTILA DE LINGUAGENS FORMAIS

MSc. Roberto Tenorio Figueiredo

2. CONCEITOS BÁSICOS ........................................................................................................... 7

3. AUTÔMATOS FINITOS ........................................................................................................ 14

6. MÁQUINAS DE TURING .......................................................................................................... 61

APÊNDICE 01: ALGORITMO SOBRE AUTÔMATOS FINITOS .......................................... 86

APÊNDICE 02: ALGORITMOS SOBRE MÁQUINAS DE TURING ...................................... 87

APÊNDICE 03: BINÁRIO REDUZIDO DA MÁQUINA DE TURING UNIVERSAL ........... 90

A teoria da computação é um estudo teórico do funcionamento interno de um computador. Visa

Uma linguagem é um meio de comunicação, formada por um conjunto de palavras e de regras

• Máquina de Turing (1936);

• Máquinas de Registradores (1963);

CARACTERE: é uma entidade abstrata básica que não é definida formalmente;

ALFABETO (∑): é o conjunto finito de símbolos distintos e indivisíveis de qualquer natureza.

Na Teoria da Computação, podemos afirmar que alfabeto é um subconjunto da tabela ASCII. Um

Exemplos: Σ = {0, 1, 2, …, 9}, Σ = {a, b, …, z}, Σ = {0,1}, Σ = {A, a, E, e, I, i, O, o, U, u}

2.1. CADEIA (C)

Exemplo 01: Exemplos de cadeia no alfabeto Σ = {a, b, c}

C1 = aab C2 = bacb C3 = b C4 = aaaccaab C5 = ccaa

2.1.1. PROPRIEDADES DA CADEIA

1. Tamanho ou Comprimento: é a quantidade de caracteres que compõem uma cadeia sejam

Exemplo 02: Exemplos (baseados no Exemplo 01) de tamanho de cadeia:

Atenção: Caso se queira a quantidade de um determinado símbolo dentro a cadeia

Exemplo 03: Exemplos de concatenação de cadeias:

C1 // C2 = aabbacb C4 // C3 = aaaccaabb C5 // C1 = ccaaaab

A concatenação é associativa, ou seja, não importará a sequência com que a concatenação

• Associatividade: (C1 // C2) // C3 = C1 // (C2 // C3).

3. Cadeia Reversa: Também chamada de Inversa, é a inversão dos elementos da cadeia,

Exemplo 04: Exemplos de cadeias reversas:

C1 = baa C2 = bcab C3 = b C4 = baaccaaa C5 = aacc

4. Elemento Neutro: Também camada de Cadeia Vazia, ou simplesmente ‘Vazio’, é a

5. Fecho: é o conjunto formado pelas cadeias geradas a partir da concatenação da cadeia

Exemplo 05: Exemplos de fechos positivos no alfabeto {a, b}:

1) a+ = {a, aa, aaa, aaaa, aaaaa, aaaaaa, aaaaaaa, ...}

5.2. Fecho Estrela: também chamado de Estrela de Kleene, é semelhante ao fecho

Exemplo 06: Exemplos de fechos estrela no alfabeto {a, b}:

1) a* = {λ, a, aa, aaa, aaaa, aaaaa, aaaaaa, aaaaaaa, ...}

2.2. LINGUAGENS (L)

2.2.1. O PODER DAS LINGUAGENS

2.2.2. PROPRIEDADES DAS LINGUAGENS

1. União ( ): A união de duas linguagens L1 e L2 é linguagem L, que contém todas as palavras

L = L1 L2 = {a, b, ab, abb, aab, abbb, aaab, aaaab, abbbb, ...}

2. Intersecção (∩): A intersecção de duas linguagens L1 e L2 é a linguagem L, que contém

Exemplo 10 (usando as linguagens do exemplo 09): L = L1 ∩ L2 = {ab}

Exemplo 11 (usando as linguagens do exemplo 09):

4. Diferença: A diferença de duas linguagens L1 e L2 é a linguagem L, que contém todas as

Exemplo 12 (usando o exemplo 09):

2.3. EXPRESSÕES REGULARES

Exemplo 13: Exemplos de Expressões Regulares no alfabeto {a, b}.

Expressão Regular Linguagem Gerada/Geradora

aa Contém somente a palavra ‘aa’

Exemplo 14: Exemplos de Expressões Regulares no alfabeto {0, 1}.

Expressão Regular Linguagem Gerada/Geradora

Exemplos de substrings do string: “abbabbbababaa”: “abbbababaa” (“abbabbbababaa”), “bbb”

1. Terminadas em 00 00 01 e iniciadas por 11;

13. Não têm nenhum “1”;

Estado: É a descrição do sistema em um determinado instante.

Transição: É uma mudança de Estado.

1. De usuário: provocada por uma ação do usuário;

O conceito de Autômato Finito, formalmente falando, é uma quíntupla, formada por:

2) q0 será sempre o estado inicial;

3) Os estados serão representados por um círculo, com seu nome no interior.

Exemplo 01: (00 (012) 210)

Exemplo 02: L = 101020

Exemplo 03: L = (0111+10) U 10*01

Separando os elementos da linguagem: L = 01+(10)+1011, temos: