2015: Fundamentos Teóricos da Computação

Fundamentos Teóricos da Computação
Copyright© Leandro Nunes de Castro 1
Slides do Curso Completo
Copyright©
2015 by Leandro Nunes de Castro
Este material foi desenvolvido com base nas seguintes referências bibliográficas: LEWIS, H.
R.; PAPADIMITRIOU, C. Elements of the theory of computation. 2. ed. Prentice Hall, 1997.
SIPSER, M. Introduction to the theory of computation. 1. ed. Brooks Cole, 1996. HOPCROFT,
J.; MOTWANI, R.; ULLMAN, J. Introduction to automata theory, languages, and computation.
2. ed. Addison-Wesley Publishing, 2000. Esse material foi desenvolvido para a disciplina
Teoria da Computação dos cursos de Ciência da Computação e Sistemas de Informação da
Universidade Presbiteriana Mackenzie, instituição sede do autor. O uso deste material para fins
acadêmicos é livre e gratuito, desde que sejam mantidas as informações originais de autoria.
Conjuntos de slides de outras disciplinas estão disponíveis no Slideshare do autor:
http://www.slideshare.net/lndecastro. Mais informações sobre o tema podem ser encontradas no
site do Laboratório de Computação Natural (LCoN): http://www.mackenzie.br/lcon.html.

CONTEÚDO
FUNDAMENTOS TEÓRICOS DA COMPUTAÇÃO........................................................................................... 1
TÓPICO 0: VISÃO GERAL DA DISCIPLINA................................................................................................... 10
1. INTRODUÇÃO................................................................................................................................. 10
1.1. AUTÔMATOS, LINGUAGENS E GRAMÁTICAS: ..............................................................................................11
1.2. COMPUTABILIDADE:.............................................................................................................................11
1.3. COMPLEXIDADE:..................................................................................................................................11
1.4. ALGUNS EXEMPLOS DE APLICAÇÃO ...........................................................................................................12
2. REVISÃO: AUTÔMATOS FINITOS..................................................................................................... 13
2.1. EXEMPLO DE APLICAÇÃO: CONTROLADOR .................................................................................................13
2.2. CONCEITOS BÁSICOS ............................................................................................................................16
2.3. DEFINIÇÃO FORMAL.............................................................................................................................18
3. REVISÃO: EXPRESSÕES REGULARES................................................................................................ 21
3.1. OPERAÇÕES COM EXPRESSÕES REGULARES ................................................................................................22
4. REVISÃO: GRAMÁTICAS ................................................................................................................. 25
4.1. DEFINIÇÃO FORMAL.............................................................................................................................27
TÓPICO 1: MÁQUINAS DE TURING........................................................................................................... 31
1. INTRODUÇÃO................................................................................................................................. 31

2. DEFINIÇÃO FORMAL DE MÁQUINAS DE TURING ............................................................................ 35
2.1. REPRESENTAÇÕES PICTÓRICAS DE UMA MT ...............................................................................................38
2.2. CONFIGURAÇÃO DE UMA MT.................................................................................................................39
2.3. COMPUTANDO COM MÁQUINAS DE TURING ..............................................................................................44
2.4. DIAGRAMAS DE TRANSIÇÃO PARA MÁQUINAS DE TURING .............................................................................49
3. ALGUMAS EXTENSÕES DAS MÁQUINAS DE TURING....................................................................... 51
3.1. FITA INFINITA EM AMBAS AS DIREÇÕES.....................................................................................................52
3.2. MÁQUINAS DE TURING DE MÚLTIPLAS FITAS..............................................................................................53
3.3. MÁQUINAS DE TURING DE MÚLTIPLOS CABEÇOTES .....................................................................................55
3.4. FITA MULTIDIMENSIONAL......................................................................................................................56
3.5. MÁQUINAS DE TURING NÃO-DETERMINÍSTICAS..........................................................................................57
4. MÁQUINAS DE TURING E COMPUTADORES CLÁSSICOS.................................................................. 58
4.1. SIMULANDO UMA MT VIA UM COMPUTADOR ............................................................................................59
4.2. SIMULANDO UM COMPUTADOR VIA UMA MT............................................................................................60
5. A TESE DE CHURCH-TURING E MÁQUINAS DE TURING UNIVERSAIS ............................................... 64
TÓPICO 2: DECIDIBILIDADE ...................................................................................................................... 67
6. INTRODUÇÃO................................................................................................................................. 67
6.1. COMPUTABILIDADE ..............................................................................................................................67
6.2. MOTIVAÇÃO ......................................................................................................................................69
7. EXEMPLOS DE PROBLEMAS NÃO DECIDÍVEIS.................................................................................. 72
7.1. “HELLO, WORLD”................................................................................................................................72

7.2. UM PROBLEMA PARCIALMENTE COMPUTÁVEL ...........................................................................................76
7.3. O PROBLEMA DA PARADA (THE HALTING PROBLEM) ...................................................................................77
7.4. O PROBLEMA DA CORRESPONDÊNCIA DE POST ...........................................................................................82
8. PROBLEMAS DECIDÍVEIS ENVOLVENDO LINGUAGENS REGULARES................................................. 85
9. PROBLEMAS DECIDÍVEIS ENVOLVENDO LINGUAGENS LIVRES DE CONTEXTO ................................. 95
TÓPICO 3: COMPLEXIDADE COMPUTACIONAL........................................................................................101
10. INTRODUÇÃO................................................................................................................................101
11. MEDINDO A COMPLEXIDADE ........................................................................................................102
11.1. A NOTAÇÃO BIG-O............................................................................................................................104
11.2. ANÁLISE DE ALGORITMOS....................................................................................................................111
11.3. RELAÇÕES DE COMPLEXIDADE ENTRE MODELOS........................................................................................122
12. A CLASSE P ....................................................................................................................................126
12.1. EXEMPLOS DE PROBLEMAS EM P...........................................................................................................129
13. A CLASSE NP..................................................................................................................................139
13.1. EXEMPLOS DE PROBLEMAS EM NP ........................................................................................................141
14. A DISTINÇÃO P  NP......................................................................................................................150
TÓPICO 4: PROBLEMAS NP-COMPLETOS.................................................................................................152
15. INTRODUÇÃO................................................................................................................................152
16. REDUÇÃO POLINOMIAL.................................................................................................................155

16.1. EXEMPLO: SATISFIABILITY PROBLEM.......................................................................................................158
17. DEFINIÇÃO FORMAL DE PROBLEMAS NP-COMPLETOS ..................................................................164
17.1. O TEOREMA DE COOK-LEVIN................................................................................................................164
18. PROBLEMAS NP-HARD ..................................................................................................................167
19. EXEMPLOS DE PROBLEMAS NP-COMPLETOS.................................................................................168
19.1. CONJUNTOS INDEPENDENTES (INDEPENDENT SETS) ...................................................................................171
19.2. COBERTURA DE VÉRTICES OU NÓS (VERTEX COVER) ..................................................................................178
TÓPICO 5: COMPUTAÇÃO DE DNA ..........................................................................................................185
1. INTRODUÇÃO................................................................................................................................185
1.1. COMPUTAÇÃO DE DNA X COMPUTADORES TRADICIONAIS ..........................................................................186
2. CONCEITOS BÁSICOS DE BIOLOGIA MOLECULAR...........................................................................187
2.1. A MOLÉCULA DE DNA .......................................................................................................................187
2.2. MANIPULANDO O DNA ......................................................................................................................193
3. MODELOS BASEADOS EM FILTRAGEM...........................................................................................199
3.1. O EXPERIMENTO DE ADLEMAN .............................................................................................................199
3.2. A SOLUÇÃO DE LIPTON PARA O PROBLEMA SAT .......................................................................................208
3.3. LINGUAGEM DE PROGRAMAÇÃO DE TUBOS DE ENSAIO ...............................................................................215
4. UM BREVE RESUMO DOS MODELOS FORMAIS..............................................................................224
5. COMPUTADORES UNIVERSAIS DE DNA .........................................................................................226

6. ESCOPO DA COMPUTAÇÃO DE DNA..............................................................................................231
7. DISCUSSÃO ...................................................................................................................................233
TÓPICO 6: COMPUTAÇÃO QUÂNTICA .....................................................................................................237
20. INTRODUÇÃO E MOTIVAÇÃO ........................................................................................................237
21. CONCEITOS BÁSICOS DA TEORIA QUÂNTICA .................................................................................240
21.1. DA MECÂNICA CLÁSSICA À MECÂNICA QUÂNTICA.....................................................................................240
21.2. A DUALIDADE ONDA-PARTÍCULA ..........................................................................................................244
21.3. O PRINCÍPIO DA INCERTEZA..................................................................................................................252
21.4. ALGUNS COMENTÁRIOS ......................................................................................................................254
22. PRINCÍPIOS DE MECÂNICA QUÂNTICA...........................................................................................255
22.1. A NOTAÇÃO DE DIRAC........................................................................................................................256
22.2. SUPERPOSIÇÃO QUÂNTICA...................................................................................................................258
22.3. PRODUTOS TENSORES.........................................................................................................................259
22.4. EMARANHAMENTO (ENTANGLEMENT)....................................................................................................260
22.5. EVOLUÇÃO (DINÂMICA)......................................................................................................................263
22.6. MEDIÇÃO ........................................................................................................................................265
22.7. TEOREMA ‘NO-CLONING’....................................................................................................................267
23. INFORMAÇÃO QUÂNTICA .............................................................................................................270
23.1. BITS E BITS QUÂNTICOS ......................................................................................................................270
23.2. MÚLTIPLOS BITS E QUBITS...................................................................................................................274
23.3. PORTAS LÓGICAS E PORTAS QUÂNTICAS..................................................................................................276

23.4. CIRCUITOS QUÂNTICOS.......................................................................................................................282
24. EXEMPLOS DE APLICAÇÃO.............................................................................................................285
24.1. CODIFICAÇÃO DENSA..........................................................................................................................285
24.2. TELETRANSPORTE QUÂNTICO ...............................................................................................................288
25. COMPUTADORES QUÂNTICOS UNIVERSAIS...................................................................................292
25.1. O COMPUTADOR DE D. DEUTSCH..........................................................................................................293
APÊNDICE: FUNDAMENTOS MATEMÁTICOS ...........................................................................................297
26. CONJUNTOS E OPERAÇÕES COM CONJUNTOS...............................................................................297
27. SEQUÊNCIAS E TUPLAS..................................................................................................................300
27.1. SEQUÊNCIA ......................................................................................................................................300
27.2. TUPLAS ...........................................................................................................................................300
28. FUNÇÕES.......................................................................................................................................301
29. TEORIA DOS GRAFOS ....................................................................................................................303
29.1. EXEMPLOS DE PROBLEMAS COMBINATORIAIS COM REPRESENTAÇÃO EM GRAFOS .............................................308
30. ALFABETOS, SENTENÇAS E LINGUAGENS.......................................................................................311
31. DEFINIÇÕES, TEOREMAS E PROVAS...............................................................................................316
31.1. CONCEITOS BÁSICOS ..........................................................................................................................316
31.2. TIPOS DE PROVAS FORMAIS .................................................................................................................317
32. ESCALARES, VETORES E MATRIZES ................................................................................................324

32.1. ESCALAR..........................................................................................................................................324
32.2. VETOR ............................................................................................................................................324
32.3. MATRIZ...........................................................................................................................................326
32.4. CONCEITOS ADICIONAIS PARA MATRIZES.................................................................................................327
33. OPERAÇÕES ELEMENTARES ENTRE VETORES E MATRIZES .............................................................329
34. ESPAÇO VETORIAL LINEAR ............................................................................................................332
34.1. AXIOMAS (PROPRIEDADES VETORIAIS)....................................................................................................333
34.2. PROPRIEDADES ADICIONAIS .................................................................................................................334
34.3. SUBESPAÇO VETORIAL LINEAR ..............................................................................................................334
34.4. COMBINAÇÃO LINEAR E COMBINAÇÃO CONVEXA ......................................................................................335
34.5. DEPENDÊNCIA LINEAR DE UM ESPAÇO VETORIAL.......................................................................................336
35. PRODUTO INTERNO ......................................................................................................................337
36. PRODUTO EXTERNO......................................................................................................................338
37. NÚMEROS E ESPAÇOS COMPLEXOS...............................................................................................339
37.1. COMPLEXO CONJUGADO E VALOR ABSOLUTO ..........................................................................................340
37.2. PLANO COMPLEXO.............................................................................................................................341
37.3. COORDENADAS POLARES.....................................................................................................................342
37.4. VETORES EM
N
..................................................................................................................................343
37.5. PRODUTO INTERNO EM
N
....................................................................................................................343
37.6. MATRIZES COMPLEXAS .......................................................................................................................344
37.7. MATRIZES COMPLEXAS ESPECIAIS: AUTO-ADJUNTA (HERMITIANA), UNITÁRIA.................................................344
37.8. ESPAÇOS DE HILBERT..........................................................................................................................345

37.9. PRODUTO TENSOR.............................................................................................................................346
38. TRANSFORMAÇÕES AFINS.............................................................................................................347
39. DISTRIBUIÇÃO DE PROBABILIDADE ...............................................................................................350

Tópico 0: Visão Geral da Disciplina
1. Introdução
 Questão central da Teoria da Computação:
Qual é a capacidade e quais são as limitações fundamentais dos
computadores?
 Estrutura da Teoria da Computação:
Teoria da Computação
Autômatos, Linguagens,
Gramáticas
Computabilidade Complexidade

1.1. Autômatos, Linguagens e Gramáticas:
 Definições e propriedades dos modelos formais (matemáticos) de computadores;
 Formam a base da computabilidade e complexidade.
1.2. Computabilidade:
 Permite determinar quais problemas são computáveis, ou seja, resolvíveis
computacionalmente.
 Exemplo de problema não-computável: determinar se uma expressão matemática
é verdadeira ou falsa.
 Como consequência da computabilidade, torna-se necessário desenvolver modelos
formais (matemáticos) de computadores.
1.3. Complexidade:
 O que torna alguns problemas difíceis de serem resolvidos computacionalmente e
outros fáceis?
 Exemplos:

 Fácil: ordenação de números.
 Difícil: agendamento (scheduling).
 Embora não haja resposta para a questão central da complexidade, é possível
verificar quais problemas são computáveis (decidíveis) e estimar o custo teórico
em termos de espaço e tempo para se resolver um dado problema.
 Saber que um problema é difícil de resolver tem várias implicações:
 Pode-se investigar a característica que torna o problema difícil;
 Pode-se aceitar soluções subótimas; e
 Pode-se considerar o uso de técnicas alternativas (p. ex. heurísticas ou
computação bioinspirada) como as melhores e, em muitos casos, as únicas
técnicas possíveis de solução.
1.4. Alguns exemplos de aplicação
 Gramáticas e linguagens livres de contexto: projeto de novas linguagens de
programação para aplicações específicas e inteligência artificial;

 Autômatos finitos e expressões regulares: processamento de texto, busca de
sentenças, casamento de padrões, compiladores e projeto de hardware;
 Complexidade computacional: custo (tempo/espaço) de solução de um dado
problema;
 Decidibilidade: determinação de quais problemas são computáveis.
2. Revisão: Autômatos Finitos
 Os autômatos são modelos computacionais simplificados e com memória limitada.
 Os autômatos finitos constituem o centro da computação ubíqua.
 Eles estão presentes em diversas aplicações do nosso dia a dia, como
controladores simples, sistemas de reconhecimento de padrões e outros
dispositivos eletromecânicos.
2.1. Exemplo de Aplicação: Controlador
 Suponhamos que nosso objetivo seja projetar um controlador simples para portas
automáticas de supermercados, shoppings, etc.

 Este controlador deve funcionar da seguinte maneira:
o Sensores serão colocados na parte interior e exterior da porta.
o Sempre que houver uma pessoa em um dos lados da porta, o controlador deverá
enviar um sinal promovendo a abertura da porta.
o Caso contrário, a porta deverá fechar ou permanecer fechada.
 Para implementar este controlador vamos utilizar um autômato finito
determinístico (DFA – deterministic finite automaton).
 O comportamento do controlador pode ser descrito de duas maneiras:
o Através de um diagrama de transição; ou
o Através de uma tabela de transição.

Sensor externo (E)
Sensor interno (I)
Porta
Figura 1: Exemplo de problema de controle a ser implementado usando um autômato finito.
 Autômato finito para controlar a porta:
q1 q2
N
E,I,A N
E,I,A
Legenda:
E: sensor externo ativado
I: sensor interno ativado
A: ambos os sensores ativados
N: nenhum sensor ativado
Figura 2: Diagrama de transição de um DFA para controlar a porta.

Q = {q1,q2}, onde q1 é o estado aberto e q2 é o estado fechado
 = {A,E,I,N}, Q1, F = Q2
Tabela de transição :
Estado
Sinal de entrada
Nenhum Externo Interno Ambos
Aberto
Fechado
Fecha Abre Abre Abre
Fecha Abre Abre Abre
EPC 01: Projete um controlador de um elevador de um prédio de 3 andares (mais o
térreo) usando um autômato finito. Neste caso, o estado do controlador corresponde
ao andar no qual ele se encontra e os sinais de entrada são recebidos do passageiro.
2.2. Conceitos Básicos
 Os autômatos podem ser classificados como determinísticos ou não-
determinísticos.
 Eles recebem os eventos em sequência, como valores de entrada.
 O resultado se reflete em mudança de estado a partir de um estado inicial.

 Os valores de entrada podem ser abstratamente interpretados como sentenças ou
sentenças de uma linguagem.
 Portanto, os autômatos operam como reconhecedores de certas linguagens.
 Para efeitos ilustrativos, considere o autômato apresentado na Figura 3.
q1 q2
1
0 1
q3
0,1
0
Figura 3: Autômato finito M1 com três estados.
 Esta figura é denominada de diagrama de estados de M1.
 Estados: q1, q2 e q3.
 Estado inicial: q1 (indicado pela seta entrando no nó).
 Estado aceito: q2 (indicado pela circunferência dupla).

 Setas: indicam transição de estados.
 Note que no exemplo da Figura 3 o autômato aceita diversas sentenças, como 1,
01, 1111, 100, 00100, etc.
EPC 02: Descreva a linguagem que consiste em todas as sentenças aceitas por M1.
2.3. Definição Formal
 Um autômato finito M é uma 5-tupla, M = Q,,,q0,F, onde
o Q é um conjunto finito denominado de estados;
o  é um conjunto finito denominado de alfabeto;
o  : Q    Q é a função de transição;
o q0  Q é o estado inicial; e
o F  Q é o conjunto de estados aceitos.
 A função de transição (q,a) = p, p,q  Q e a  , pode ser interpretada da
seguinte forma:

o Se o controle de M está no estado q e o próximo símbolo de entrada for a, então
a deve ser reconhecido e o controle passa para o estado p.
 Logicamente, um estado é uma situação particular no processo de reconhecimento
de uma sentença.
 Uma sentença w é aceita por um autômato M = Q,,,q0,F se, a partir do estado
q0, ao final do processamento de w, o autômato chegou a um estado final ou
aceito.
 Uma linguagem reconhecida por um autômato é o conjunto de todas as sentenças
aceitas pelo autômato.
 Exemplo:
o No caso do autômato ilustrado na Figura 3, ele pode ser formalmente descrito
como: M1 = Q,,,q0,F, onde Q = {q1, q2, q3},  = {0,1}, q1 é o estado inicial,
F = {q2} e a função de transição está resumida na matriz abaixo:

0 1
q1
*q2
q3
q1 q2
q3 q2
q2 q2
Dito de outra forma:
(q1,0) = q1 (q1,1) = q2
(q2,0) = q3 (q2,1) = q1
(q3,0) = q2 (q3,1) = q2
 Se A é o conjunto de todas as sentenças que a máquina M aceita, então dizemos
que A é a linguagem da máquina M: L(M) = A.
 Dizemos que M reconhece A ou que M aceita A.
 Obs.: uma máquina pode aceitar diversas sentenças, mas reconhece uma única
linguagem.
 Se a máquina não aceita sentença alguma, ela ainda reconhece uma linguagem, a
linguagem vazia .

3. Revisão: Expressões Regulares
 As expressões regulares fornecem uma descrição algébrica de linguagens ao invés
daquela descrição mecânica (através de uma máquina) estudada via autômatos
finitos.
 As expressões regulares podem definir exatamente as mesmas linguagens que os
vários tipos de autômatos descrevem: as linguagens regulares.
 Entretanto, as expressões regulares oferecem uma forma declarativa de expressar
as sentenças que precisam ser aceitas ou não.
 Portanto, as expressões regulares servem de linguagem de entrada para diversos
sistemas que processam sentenças. Exemplos:
o Comandos de busca como grep ou comandos equivalentes em Unix. Estes
sistemas usam uma notação similar a expressões regulares para descrever
padrões que o usuário quer encontrar em um arquivo. Diferentes sistemas de

busca convertem a expressão regular em um DFA ou um NFA e simulam o
autômato no arquivo sendo pesquisado.
o Geradores de análise léxica, como Lex e Flex. O analisador léxico é o
componente do compilador que quebra o programa fonte em unidades lógicas
(tokens) de um ou mais caracteres que possuem uma significância
compartilhada. Os analisadores léxicos aceitam descrições sob a forma de
tokens, que são essencialmente expressões regulares, e produzem um DFA que
reconhece qual token aparece na sequência de entrada.
3.1. Operações com Expressões Regulares
 Expressões regulares denotam linguagens. Exemplo:
o A expressão regular 01*10* denota a linguagem que consiste em todas as
sentenças compostas por um único 0 seguido de qualquer quantidade de 1s ou
um único 1 seguido de qualquer quantidade de 0s.

 Sejam as linguagens L = {001, 10, 111} e M = {, 001}. Há três operadores sobre
linguagens que representam os operadores das expressões regulares:
o União (L  M): L  M = {x | x  L ou x  M}
L  M é o conjunto de sentenças que estão em ambas as linguagens L e M.
Exemplo: L  M = {, 10, 001, 111}.
o Concatenação (L○M = L.M = LM): L○M = {xy | x  L e y  M}
LM é o conjunto de sentenças que podem ser formadas tomando-se qualquer
sentença em L e concatenando-a com qualquer sentença em M. Exemplo:
LM = {10, 001, 111, 001001, 10001, 111001}
o Fechamento (L*): L* = {x1 x2 ... xk | k  0 e cada xi  L}
L* representa o conjunto das sentenças que podem ser formadas tomando-se
qualquer quantidade de sentenças de L, possivelmente com repetições, e
concatenando-as. Ou seja, L* é a união infinita i0 Li
, onde L0
= {}, L1
= L, e
Li
, i > 1 é LL...L (concatenação de i cópias de L).

 Exemplos:
o Seja L = {0, 11}. Determine L3
.
L0
= {}
L1
= {0,11}
L2
= {00,011,110,1111}
L3
= L.L2
= {000,0011,0110,01111,1100,11011,11110111111}
o Seja  o alfabeto com 26 letras {a,b,...,z}. Se L = {good, bad} e M = {boy,
girl}, então:
L  M = {good,bad,boy,girl}
L○M = {goodboy,goodgirl,badboy,badgirl}
L* = {,good,bad,goodgood,goodbad,badgood,badbad,goodgoodgood,...}
EPC 03: Descreva as linguagens correspondentes às seguintes expressões regulares
(Assuma  = {0,1}):

(01)0* (01)*
(0*)(*1) 0*10*
*0*1 1001
010**1 (1)0*
()* *
EPC 04: Seja L o conjunto de todas as sentenças de 1s. Compute L*.
4. Revisão: Gramáticas
 Formalmente, as representações finitas de linguagens classificam-se em:
o Sistemas reconhecedores: são dispositivos formais que nos permitem verificar
se uma determinada sentença pertence ou não a uma dada linguagem.
Exemplos: autômatos e máquinas de Turing.
o Sistemas geradores: são dispositivos formais dotados de mecanismos que
permitem a geração sistemática de sentenças de uma linguagem.

 Os principais sistemas geradores disponíveis são as gramáticas, dentre as quais
podemos destacar as gramáticas de Chomsky.
 Como discutido no Apêndice, uma linguagem L é qualquer conjunto ou
subconjunto de sentenças sobre um alfabeto *, ou seja, L  *.
 A finalidade de uma gramática é definir o subconjunto de * que forma (define)
uma determinada linguagem.
*
L
Gramática
Figura 4: L  *.

 Uma gramática define uma estrutura sobre um alfabeto de forma a permitir que
apenas determinadas combinações sejam válidas.
 Uma gramática realiza a validação de sentenças de uma linguagem.
 Informalmente podemos definir uma gramática como sendo:
o Um sistema gerador de linguagens.
o Uma maneira finita de escrever ou representar uma linguagem.
o Um dispositivo formal usado para especificar de maneira finita e precisa uma
linguagem potencialmente infinita.
4.1. Definição Formal
 Uma gramática pode ser descrita por uma quádrupla G = V,,P,S, onde:
o V é um conjunto finito de variáveis, também denominados de categorias
sintáticas ou não-terminais. Cada variável representa uma linguagem, ou seja,
um conjunto de sentenças.

o  é um conjunto finito de símbolos que formam as sentenças da linguagem
sendo definida. O conjunto destes símbolos, denominados terminais, forma o
alfabeto da linguagem.
o P corresponde ao conjunto de regras ou produções que representam a definição
recursiva da linguagem. Cada produção consiste em um antecedente e um
consequente separados pelo símbolo “” ou “::=”.
o S é o símbolo inicial, algumas vezes denominado de axioma, que corresponde à
variável, S  V, que representa a linguagem sendo definida.
 Exemplo:
Seja um subconjunto da gramática da língua portuguesa:
frase  sujeito predicado
sujeito  substantivo
| artigo substantivo
| artigo adjetivo substantivo

 Formalmente o subconjunto da gramática da língua portuguesa é G = V,,P,S, tal
que:
 V = {frase,sujeito,predicado,substantivo,artigo,adjetivo,verbo,
objeto}
  = {joão, Maria, cachorro, livro, pão, o, a, pequeno, bom, bela, morde, lê,
olha}
 P = conjunto das regras gramaticais apresentadas
 S = frase
EPC 05: Desenvolva uma gramática que gere as seguintes linguagens:
a) L(G) = {an
bm
| n  0, m  1}
b) L(G) = {an
b2n
| n  1}

Tópico 1: Máquinas de Turing
1. Introdução
 Neste tópico veremos quais linguagens podem ser definidas por qualquer
dispositivo computacional.
 Esta questão é central para verificação do potencial dos computadores, pois
reconhecer a sentença de uma linguagem é a maneira formal de expressar qualquer
problema, e a capacidade de resolução de problemas nos permite verificar o
potencial dos computadores.
 Na disciplina Linguagens Formais e Autômatos foram apresentados diversos
modelos de dispositivos computacionais como, por exemplo, autômatos finitos.
Foi mostrado que mesmo alguns problemas muito simples estão além da
capacidade destes modelos e, portanto, eles são muito restritos para servir como
modelos de computadores de uso (ou propósito) geral.

 As Máquinas de Turing (MT) possuem este nome devido a seu inventor, Alan
Turing (1912-1954).
 As MT são similares aos autômatos finitos, mas possuem uma memória ilimitada
e irrestrita, e constituem um modelo de computador de propósito geral muito mais
preciso.
 Embora as máquinas de Turing possam fazer tudo que um computador ‘real’ pode
fazer, há algumas classes de problemas que elas não podem resolver. Mais
especificamente, estes problemas estão além dos limites teóricos da computação.
 Uma máquina de Turing é composta por quatro partes:
o Fita (tape): responsável por armazenar informação (memória). É dividida em
posições discretas ou células e possui tamanho infinito;
o Cabeçote (tape head): responsável pela leitura e escrita de símbolos na fita e
pela movimentação na fita;

o Registrador de estados (state register): responsável por armazenar o estado
da máquina;
o Tabela de instruções ou programa: responsável por controlar a máquina, ou
seja, indicar qual símbolo escrever, como mover o cabeçote e qual o novo
estado.
 A definição formal de uma MT e sua operação segue o mesmo padrão matemático
da definição dos autômatos finitos.
 Entretanto, é possível demonstrar que tentativas de obter ganhos em termos de
poder computacional através de melhorias ou combinações de MT resultam em
sistemas com poder computacional que não é maior do que o de uma MT básica.
o Isso pode ser mostrado através de simulação: é possível converter qualquer
‘MT melhorada’ em uma máquina básica que funciona de maneira análoga.

 É possível ir mais longe e mostrar que as MT são equivalentes em poder a formas
completamente diferentes de realizar computação que não são baseadas em
autômatos com estados e fitas.
o Também é possível mostrar a universalidade de novos paradigmas de
computação baseado nos princípios da universalidade das máquinas de
Turing.
 As MT são projetadas para satisfazer simultaneamente três critérios:
o Sua construção e funcionamento seguem o princípio geral dos autômatos;
o Elas devem ser simples de descrever e definir formalmente;
o Elas devem ser genéricas em relação às computações que podem executar.
 Resumo das diferenças entre os autômatos finitos e as MT:
o Uma MT pode escrever e ler a fita;
o O cabeçote de uma máquina de Turing pode se mover para esquerda ou para
a direita;

o A fita é infinita;
o Os estados especiais para rejeitar e aceitar possuem efeito direto.
 Há um estado especial chamado de estado de parada (halt state – h), que é usado
para sinalizar o fim de uma computação.
2. Definição Formal de Máquinas de Turing
 Uma Máquina de Turing é uma quádrupla (Q,,,s) onde:
o Q é um conjunto de estados, incluindo o estado de parada (halt state – h);
o  é um alfabeto contendo o símbolo vazio #, mas não contendo os símbolos
de movimentação L, R e N;
o  é uma função de transição de estados : Q    (Q    {L,R,N}), onde
{L,R,N} indica o movimento do cabeçote para a esquerda (L), direita (R), ou
nenhum movimento (N).
o s  Q é o estado inicial.

 Um movimento da máquina de Turing é função de seu estado atual e do símbolo
lido a partir da fita. Em um movimento M poderá:
o Mudar de estado. O próximo estado pode ser o mesmo estado atual.
o Escrever um símbolo na célula lida. O novo símbolo pode ser igual ao atual.
o Mover o cabeçote para a direita, esquerda ou permanecer na mesma posição.
 A configuração inicial de uma máquina M para a entrada w é a configuração sw,
que indica que M está no estado inicial s com o cabeçote na posição mais a
esquerda da fita. Em uma configuração de parada a máquina está no estado h.
 Uma máquina de Turing M aceita a entrada w se uma sequência de configurações
C1, C2, ... , Ck existe tal que:
o C1 é a configuração inicial de M;
o Cada Ci leva a Ci+1; e
o Ck é uma configuração aceita.
 A coleção de sentenças que M aceita é a linguagem de M, denotada por L(M).

 Definição 01: Uma linguagem é Turing-reconhecível, ou recursivamente
enumerável, se alguma máquina de Turing a reconhece.
 Definição 02: Uma linguagem é Turing-decidível, decidível ou recursiva, se
alguma máquina de Turing a decide.
 Toda linguagem decidível é recursivamente enumerável, mas algumas linguagens
recursivamente enumeráveis não são decidíveis.
 Exemplo 1:
Dada M = (Q,,,s). Se q  Q, a  , e (q,a) = (p,b,L), então M enquanto no
estado q e lendo o símbolo a, entrará no estado p, escreverá o símbolo b no lugar
de a e moverá o cabeçote para a esquerda.
Dada M = (Q,,,s). Se q  Q, a  , e (q,a) = (p,b), então M enquanto no
estado q e lendo o símbolo a, entrará no estado p e poderá executar uma das duas
operações abaixo:
. Se b  , substitua a por b

. Se b  {L,R,N}, então mova o cabeçote de acordo com o símbolo b.
Nota:  é uma função que determina exatamente qual a próxima configuração da
MT e, portanto, esta MT é denominada de determinística.
2.1. Representações Pictóricas de uma MT
 A máquina de Turing descrita formalmente acima pode ser representada de
algumas formas distintas como, por exemplo:
. . .
q
x1 x2 x3 x4
Figura 5: Representação pictórica de uma máquina de Turing M no estado q, lendo o
símbolo x2. (Os espaços em branco correspondem a #.)

 A mesma máquina de Turing ilustrada acima pode ser representada como abaixo:
q
q1 h
. . .x1 x2 x3 x4
q
q1 h
. . .x1 x2 x3 x4
(a) (b)
Figura 6: (a) Outra representação pictórica de uma máquina de Turing M no estado q, lendo
o símbolo x2. Nesta figura aparecem outros possíveis estados de M: q1 e h. (Os espaços em
branco correspondem a #.) (b) M está no estado de parada h lendo o símbolo x3.
2.2. Configuração de uma MT
 Para especificar o status de uma computação da MT, é preciso especificar o estado
da máquina, o conteúdo da fita e a posição do cabeçote.

 Como apenas uma porção finita da máquina conterá o símbolo #, o conteúdo da
fita pode ser representado por uma sentença (sentença).
 Assim como a própria definição formal de máquina de Turing, a representação de
uma configuração também possui variantes. Segue abaixo uma delas:
o Cada computação (passo ou estágio) de uma máquina de Turing pode ser
representada por uma sequência de configurações instantâneas da máquina,
onde cada configuração C = (x1…xk1qxkxk+1…xm), xi   e q  Q, codifica
um único passo da computação. A sentença x1…xm é a porção da fita entre os
símbolos mais a esquerda e mais a direita diferentes de #.
Formalmente, a configuração de M é um membro de:
  Q    

 Exemplo 2:
. . .
q
x1 x2 x3 x4
No caso do exemplo da figura acima tem-se: C = (x1qx2x3x4).
o A sentença que representa a configuração da MT pode ser quebrada em três
partes: 1) a primeira (que pode ser vazia), à esquerda da posição sendo lida;
2) o símbolo único sendo lido; e 3) a parte à direita da posição sendo lida.
Além disso, para que não haja redundância nas possíveis triplas geradas, a
última sub-sentença não deve terminar com um símbolo # (quaisquer
símbolos à direita do último são assumidos conter #).

 Exemplo 3:
. . .
q
x1 x2 x3 x4
C = (q,x1,x2,x3x4), onde xi   e q  Q. (Similar a anterior.)
EPC 1: Apresente a configuração instantânea das máquinas de Turing ilustradas
abaixo:
. . .
q1
x y z . . .
q0
x1 x2 x3 x4
(a) (b)

q
q1 h
. . .x1 x2 x3 x4
(c)
EPC 2: Para a MT dada abaixo, determine se ela chega a um estado de parada
quando a sentença a#a# é apresentada. Explique.
Q = {q0, q1};  = {a, #}; s = q0
e  é dado pela tabela abaixo:
q  (q,)
q0 a (q1,#)
q0 # (h,#)
q1 a (q0,a)
q1 # (q0,R)

2.3. Computando com Máquinas de Turing
 É usual descrever movimentos de uma máquina de Turing M = (Q,,,s)
utilizando a notação ‘├M’.
 Exemplo 4:
Assuma a seguinte função de transição (q,xi) = (p,y,L). Então a descrição de um
movimento (passo) pode ser dada por:
x1…xk1qxkxk+1…xm├M x1…xk2pxk1yxk+1…xm
 Este movimento reflete a mudança para o estado p, a escrita de y na posição xi e o
fato de que o cabeçote agora está posicionado na célula i1 (k1).
 Há duas exceções para esta representação:
o Se i = 1, então M se move para o vazio a esquerda de x1:
qx1…xm├M p#yx2…xm
o Se i = m e y = #, então o símbolo # é escrito sobre xm e não aparece na
configuração:

x1…qxm├M x1…pxm1
 Exemplo 5:
Assuma agora a seguinte função de transição com movimento para a direita
(q,xi) = (p,y,R). Neste caso, a descrição de um movimento (passo) pode ser dada
por:
x1…xk1qxkxk+1…xm├M x1…xk1ypxk+1…xm
 Este movimento reflete a mudança para o estado p, a escrita de y na posição xi e o
fato de que o cabeçote agora está posicionado na célula i+1 (k+1).
 Também há duas exceções para esta representação:
o Se i = m, então a célula i + 1 possui o estado vazio:
x1…xm1qxm├M x1…xm1yp#
o Se i = 1 e y = #, então o símbolo # é escrito sobre x1 e não aparece na nova
configuração:
qx1…xm ├M px2…xm

 Uma computação realizada por M é uma sequência de configurações C0, C1,...,Cn,
n  0, tal que:
C0├M C1├M C2├M ... ├MCn
 Neste caso diz-se que a computação tem comprimento n, ou n passos.
 Exemplo 6:
Considere a seguinte MT: M = (Q,,,s), onde:
Q = {q0,q1};  = {a,#}; s = q0
q  (q,)
q0 a (q1,#)
q0 # (h,#)
q1 a (q0,a)
q1 # (q0,R)
Descreva a computação realizada por M assumindo que M possui a seguinte
sequência de símbolos escrita na fita (configuração inicial): aaaa#.

q0aaa ├M q1#aaa (passo 1)
├M #q0aaa
├M #q1#aa (passo 3)
├M ##q0aa
├M ##q1#a (passo 5)
├M ###q0a
├M ###q1# (passo 7)
├M ####q0
├M ####h (passo 9)
EPC 3: Considere a seguinte MT: M = (Q,,,s), onde:
Q = {q0};  = {a,#}; s = q0

q  (q,)
q0 a (q0,L)
q0 # (h,#)
Explique informalmente o que M faz e descreva a computação realizada por M
assumindo que M possui a seguinte configuração inicial: aaq0a.
EPC 4: Considere a seguinte MT: M = (Q,,,s), onde:
Q = {q0,q1,q2};  = {a,b,#}; s = q0

q  (q,)
q0 a (q1,L)
q0 b (q1,L)
q0 # (q1,L)
q1 a (q0,b)
q1 b (q0,a)
q1 # (q2,R)
q2 a (q2,R)
q2 b (q2,R)
q2 # (h,#)
Explique informalmente o que M faz e descreva a computação realizada por M
assumindo que M possui a seguinte configuração inicial: #aabq0#.
2.4. Diagramas de Transição para Máquinas de Turing
 É possível representar as transições de estado de uma máquina de Turing
pictóricamente, como feito para os autômatos finitos.

 Um diagrama de transição (de estados) consiste em um conjunto de nós
correspondente aos estados da máquina de Turing. Um arco ligando um estado q a
um estado p é nomeado por um ou mais itens da forma x/yD, onde x, y  
(símbolos) e D  {R,L,N} é uma direção de movimentação. Quando a direção não
aparece no diagrama, isso significa que a máquina não muda a posição de leitura e
escrita na fita.
 Exemplo 7:
Diagrama de transição de estados da máquina de Turing do Exemplo 6.
q0
h
q1
a/#
#/#R
a/a
#/#

EPC 5: Desenhe os diagramas de transição das máquinas de Turing do EPC 3 e do
EPC 4.
3. Algumas Extensões das Máquinas de Turing
 As Máquinas de Turing são capazes de realizar computações de considerável
complexidade, porém de forma lenta e ineficiente.
 Com o objetivo de investigar a possibilidade de projetar autômatos com maior
poder computacional, considera-se o efeito de estender o modelo de Máquinas de
Turing de várias formas.
o Entretanto, boa parte das extensões não aumenta a classe de funções
computáveis ou linguagens reconhecidas pela MT.
 Um benefício extra destas extensões é permitir um projeto mais eficiente de MTs
para aplicações específicas.
 As principais extensões das MT são:

o Fita infinita em ambas as direções: permitir que a fita tenha tamanho infinito
em ambas as direções, e não apenas para a direita.
o Máquinas de Turing de Múltiplas Fitas: permitir que a MT tenha mais de
uma fita;
o Máquinas de Turing de Múltiplos Cabeçotes: permitir que a MT tenha mais
de um cabeçote;
o Fita Multidimensional: permitir que a MT tenha uma fita de dimensão dois
ao invés de um;
o Máquinas de Turing Não-Determinísticas: permitir que um dentre um
conjunto finito de movimentos seja possível (escolhido probabilisticamente).
3.1. Fita Infinita em Ambas as Direções
 Neste caso a fita não possui distinção entre a extremidade esquerda e a direita.
 Uma sentença de entrada pode ser colocada em qualquer posição da fita e o
cabeçote posicionado no espaço vazio a sua direita.

 Uma computação procede igualmente para o caso das máquinas com fita infinita
em uma única direção, exceto que agora há células disponíveis arbitrariamente
tanto para a direita quanto para a esquerda.
 Formalmente estas máquinas são idênticas às máquinas padrão, a diferença é que
as noções de configuração e computação mudam um pouco.
EPC 6: Defina formalmente a configuração e uma computação de uma MT com fita
infinita em ambas as direções.
3.2. Máquinas de Turing de Múltiplas Fitas
 A diferença principal deste tipo de MT é a existência de mais de uma fita onde
armazenar informação. Cada fita pode ser lida ou escrita utilizando um cabeçote
distinto.
 Inicialmente:
o A entrada, uma sequência finita de símbolos de entrada, é colocada na
primeira fita.

o Todas as outras células de todas as outras fitas estão vazias.
o O sistema de controle está no estado inicial.
o O cabeçote da primeira fita está na primeira posição a esquerda da entrada.
o Todos os outros cabeçotes estão em uma célula arbitrária.
 Um movimento da MT de múltiplas fitas depende do estado e do símbolo lido por
cada um dos cabeçotes. Em um movimento (passo), esta máquina faz o seguinte:
o O controle entra em um novo estado, que pode ser o mesmo do anterior;
o Em cada fita um novo símbolo é escrito na célula lida. Qualquer um destes
símbolos pode ser o mesmo que o símbolo atual;
o Cada um dos cabeçotes se move independentemente dos demais.

. . .
. . .
. . .
Figura 7: Máquina de Turing de múltiplas fitas.
3.3. Máquinas de Turing de Múltiplos Cabeçotes
 O que acontecerá se permitirmos que uma mesma MT tenha vários cabeçotes para
ler e/ou escrever numa única fita?

 Em um passo, todos os cabeçotes vão ler os símbolos indicados e mover ou
escrever independentemente.
o Obs.: alguma convenção deve ser adotada sobre o que acontece quando dois
cabeçotes estão apontando sobre a mesma célula e tentam escrever símbolos
distintos nesta posição. Algum mecanismo de decisão deverá ser empregado.
 Assim como no caso da utilização de múltiplas fitas, o uso de múltiplos cabeçotes
pode simplificar muito a construção de uma máquina de Turing.
3.4. Fita Multidimensional
 Outra generalização de uma máquina de Turing é permitir que sua fita seja um
grid infinito bidimensional.
o É possível considerar inclusive um espaço de maior dimensão.
 Máquinas de Turing com fita bidimensional podem ser simuladas por máquinas de
Turing clássicas.

3.5. Máquinas de Turing Não-Determinísticas
 As máquinas de Turing não-determinísticas (MTND) podem ter, dadas algumas
combinações de estados e símbolos lidos, mais que um possível comportamento.
 Formalmente, a única diferença de uma MTND para uma MT clássica está na
função de transição:
: Q    P{Q    {L,R,N}}
 Outra forma de representar é a seguinte. Dado o estado atual q0 e o símbolo lido
x0, a função de transição poderá assumir qualquer uma das seguintes triplas:
{(q1,x1,D1), (q2,x2,D2), ..., (qk,xk,Dk)}, onde k é um inteiro finito que representa a
quantidade de possibilidades de mudança de configuração.

4. Máquinas de Turing e Computadores Clássicos
 É possível comparar as máquinas de Turing com os computadores convencionais
(domésticos) conhecidos atualmente.
 Ao mesmo tempo em que estes modelos parecem ser muito diferentes, eles podem
aceitar exatamente as mesmas linguagens: linguagens recursivamente
enumeráveis.
 Ao mesmo tempo que uma MT não parece nada com um PC e seria
grosseiramente ineficiente caso alguma empresa decidisse fabricá-la e vendê-la,
ela é reconhecidamente um modelo preciso para o que um dispositivo
computacional físico pode fazer.
 Como a noção do que é um computador convencional não é muito bem definida
matematicamente, a discussão a ser apresentada aqui será necessariamente
informal.

 A demonstração de equivalência entre uma máquina de Turing e computadores
clássicos será feita de duas formas:
o Mostrando que um computador comum pode simular uma MT; e
o Mostrando que uma MT pode simular um computador.
4.1. Simulando uma MT via um Computador
 Dada uma MT qualquer M = (Q,,,s), é possível escrever um programa que
opera como M. Uma característica importante de M é seu controle finito.
o Como há um conjunto finito de estados e regras de transição, o programa
pode codificar os estados como sendo cadeias de caracteres (sentenças) e usar
uma tabela de transição de estados para determinar cada movimento.
o Similarmente, os símbolos da fita podem ser codificados como sentenças de
comprimento finito.
 Questão importante: dado que a fita de M é infinita e que a memória do
computador é finita, como o computador poderá simular a fita de M?

o A resposta para esta questão é simples: substituindo ‘infinitamente’ a
memória do computador. (Desde que isso seja possível!)
o Sendo assim, é possível ter uma quantidade de memória específica para
armazenar os símbolos à direita e à esquerda da fita.
4.2. Simulando um Computador via uma MT
 Além de verificar se uma MT pode simular um computador, é importante também
comparar a eficiência computacional destes dois modelos.
 Inicialmente, consideremos como um computador clássico opera:
o Vamos assumir que o armazenamento de um computador consiste em uma
sequência infinitamente longa de palavras, cada qual com um endereço.
Enquanto as palavras possuem um comprimento dado (p. ex. 32 ou 64 bits),
os endereços serão considerados inteiros.
o O programa do computador será armazenado em algumas palavras da
memória. Estas palavras representam instruções, como em uma linguagem

assembler. Endereçamento direto será assumido possível, ou seja, uma
palavra pode referenciar outra palavra.
o Cada instrução envolve um número limitado (finito) de palavras, e cada
instrução muda o valor de no máximo uma palavra.
o Um computador típico possui registradores, que são palavras de memória
com acesso especialmente rápido.
 A máquina de Turing a ser usada para simular um computador possui várias fitas,
mas como discutido, ela é equivalente a uma máquina de fita única.

 A MT irá simular um ciclo de instrução da seguinte forma:
o Procure na memória (fita 1) o primeiro endereço que satisfaz a instrução na
fita 2.
Endereço de
memória 1000110
Contador de
instruções 001110
Memória
Arquivo de
entrada . . .
Lixo . . .

o Quando o endereço de instrução for encontrado, examine seu valor. Se uma
palavra for uma instrução, então seus primeiros bits representam a ação a ser
tomada e os demais endereços envolvidos na ação.
o Se a instrução requer o valor de algum endereço, então este endereço será
parte da instrução. Copie este endereço para a memória de endereço (fita 3) e
marque a posição da instrução. Agora procure o endereço de memória na
memória (fita 1) e copie seu valor para a memória de endereço (fita 3).
o Execute a instrução, ou parte da instrução envolvendo este valor. (Obs.: não
entraremos em detalhes sobre o que a instrução pode fazer. Exemplos: copiar,
escrever, etc.)
o Após executar a instrução adicione 1 ao contador de instrução na fita 2 e
repita o processo.
 Obs.: esta descrição é visivelmente incompleta, mas ela ilustra o potencial de uma
MT para simular um computador convencional.

5. A Tese de Church-Turing e Máquinas de Turing Universais
 O principal propósito da Teoria da Computação é apresentar uma perspectiva
matemática formal sobre o que é computação e como computar.
 Para isso, foram vistos diversos modelos abstratos de máquinas, como autômatos
finitos e agora as máquinas de Turing.
o Basicamente, trata-se de dispositivos com um número finito de estados
internos distinguíveis que opera em uma cadeia de símbolos (sentenças) de
acordo com um conjunto finito de regras.
 As MT foram projetadas para aceitar linguagens ‘complicadas’ e também para
calcular funções matemáticas não-triviais.
 O fato de que a adição de algumas características às MTs não aumenta o poder
computacional delas demonstra parte de seu potencial, e também sugere que um
limite superior natural foi alcançado para o tipo de computação que uma máquina
foi projetada para realizar.

o A questão da eficiência será tratada posteriormente, no tópico sobre
Complexidade Computacional.
 Como as MT podem realizar qualquer computação realizável por um autômato
similar e como estes autômatos parecem capturar as características essenciais de
um computador, a MT é tomada como um equivalente formal preciso da noção
intuitiva de algoritmo: nada pode ser considerado um algoritmo se ele não puder
ser realizado (computado) por uma máquina de Turing.
 De forma simples, um algoritmo é uma coleção de instruções com o objetivo de
realizar alguma tarefa. Também são denominados de procedimentos ou receitas.
 O princípio de que as MT são versões formais de algoritmos e que nenhum
procedimento computacional será considerado um algoritmo a não ser que ele
possa ser apresentado como uma MT é conhecido como a Tese de Church-Turing.
Noção intuitiva de algoritmo = Algoritmos das Máquinas de Turing

 É claro que a Tese de Church-Turing pode ser ultrapassada algum dia, quando
alguém propuser um novo modelo computacional capaz de realizar computações
que não podem ser realizadas por uma MT.
 As máquinas de Turing constituem um exemplo de Máquina de Turing Universal
(MTU), originalmente proposta por Turing.
 A denominação universal é devida a sua capacidade de simular qualquer outra MT
a partir da descrição da máquina que se deseja simular.

Tópico 2: Decidibilidade
6. Introdução
 Este tópico visa responder algumas questões centrais em teoria da computação:
o Que linguagens podem ser reconhecidas por algum tipo de autômato?
o O que é ser computável?
o Que linguagens são computáveis?
o Existem linguagens que não são computáveis? Isto é, existem problemas que
não podem ser resolvidos computacionalmente, ou seja, que são indecidíveis?
o Existem máquinas universais, isto é, que aceitam todas as linguagens
computáveis?
6.1. Computabilidade
 Um problema é computável se existir um método algorítmico de resolvê-lo, isto é,
uma sequência finita de instruções que possa ser executada mecanicamente.

 Um algoritmo computacional pode não parar para uma certa entrada, produzindo
uma sequência infinita de objetos ou sem produzir nada.
 Em estudos dos fundamentos da Matemática, iniciados por David Hilbert no início
do século XX, pretendia-se reduzir a Matemática à manipulação pura de símbolos,
e encontrar um algoritmo que determinasse a veracidade ou a falsidade de
qualquer proposição matemática.
 Foram propostos vários formalismos que se demonstraram equivalentes (no
sentido de aceitarem as mesmas linguagens):
o Máquinas de Turing (Alan Turing, 1936);
o Funções recursivas parciais (Kurt Gödel, 1931);
o -Calculus (Alonso Church, 1933);
o Lógica combinatória (Haskell Curry, 1929);
o Gramáticas não restritas ou Tipo 0 (Noam Chomsky, 1956).

 Um problema corresponde a uma linguagem num alfabeto . Resolvê-lo é
determinar se uma sentença pertence a essa linguagem.
 O número de linguagens num dado alfabeto não é numerável.
 Uma máquina (programa) que o resolva também pode ser visto como uma palavra
num dado alfabeto. Mas então só há uma quantidade enumerável de máquinas.
 Conclusão: Há mais problemas que programas!
 Donde conclui-se que:
o Têm de existir problemas indecidíveis;
o Mas pode ser difícil demonstrar que um dado problema é indecidível.
6.2. Motivação
 No tópico anterior a Máquina de Turing foi apresentada como um modelo de
computador de propósito geral.
 A tese de Church-Turing foi utilizada para apresentar uma noção de algoritmo e
discutir a universalidade das máquinas de Turing.

 No presente tópico começamos a investigar o poder dos algoritmos
(computadores) em solucionar problemas.
 Serão demonstrados alguns problemas que podem ser resolvidos via algoritmos e
outros que não podem.
 O objetivo é explorar os limites dos algoritmos (computadores) na resolução de
problemas.
 Há duas motivações principais para se estudar quais problemas podem ser
resolvidos e quais não podem:
o Saber que um problema não pode ser resolvido por um algoritmo é útil pois a
partir daí podemos tentar simplificá-lo ou alterá-lo para que ele seja resolvido
por um algoritmo.
o Mesmo sabendo que um problema pode ser resolvido, conhecer problemas
não resolvíveis pode estimular a imaginação e nos ajudar a ganhar novas
perspetivas sobre a computação e técnicas de resolução de problemas.

 A discussão será apresentada abordando a questão sobre quais linguagens podem
ser reconhecidas por um dispositivo computacional (algoritmo). Esta questão está
intimamente relacionada ao potencial dos computadores, pois o reconhecimento
de uma sentença por uma linguagem é uma maneira formal de expressar qualquer
problema, e a capacidade de resolver um problema é equivalente a estudar o que
um computador pode fazer.
 A palavra decidível é um sinônimo para recursivo, porém linguagens geralmente
são denominadas de recursivas e problemas de decidíveis.
o Se uma linguagem não é recursiva, então o problema expresso por esta
linguagem não é decidível.
o Na nossa abordagem utilizaremos ambas as terminologias para nos referir a
linguagens.
 Vamos iniciar este tópico com um argumento informal.

o Empregando um algoritmo simples escrito em linguagem de programação C,
vamos apresentar um exemplo (problema) específico que não pode ser
resolvido usando um computador.
 Posteriormente desenvolveremos uma teoria sobre problemas não-decidíveis.
7. Exemplos de Problemas Não Decidíveis
 Esta seção apresenta quatro problemas não decidíveis: 1) um problema simples,
conhecido como “Hello World”; 2) um problema parcialmente computável; 3) um
problema fundamental em teoria da computação, conhecido como problema da
parada (Halting Problem); e 4) um problema simples que não envolve linguagens.
7.1. “Hello, world”
 O problema em particular que vamos discutir aqui é se a primeira coisa que um
programa em C imprime é “hello, world”.

 Embora sejamos tentados a pensar que basta simular um programa para verificar o
que ele faz, há problemas que podem levar uma quantidade infinita de tempo antes
de fornecer uma saída.
 Entretanto, provar formalmente que não há um programa capaz de realizar uma
determinada tarefa é difícil e alguns mecanismos formais precisam ser
desenvolvidos.
 Um primeiro programa implementado por alunos da linguagem C que usam o
livro clássico de Ritchie1 imprime a sentença “hello, world” na tela do
computador.
Main()
{
printf(“hello, worldn”);
}
1 B. W. Kernighan & D. M. Ritchie, The C Programming Language, 1978, Prentice-Hall.

 Há outros programas que também imprimem “hello, world” que não são tão
óbvios quanto este.
 Por exemplo, considere o programa abaixo que recebe uma entrada n e procura
inteiros positivos que sejam solução da seguinte equação:
xn
+ yn
= zn
 Se o algoritmo encontrar uma tripla (x,y,z) que satisfaça a equação acima, então
ele imprime “hello, world”. Caso contrário ele continua a busca eternamente e
nunca imprime “hello, world”.
 Se o valor lido de n for 2 por exemplo, n = 2, então o programa irá eventualmente
encontrar x = 3, y = 4 e z = 5 que satisfaz a equação.
 Para valores inteiros n > 2, o programa jamais encontrará uma tripla (x,y,z) que
satisfaça xn
+ yn
= zn
e, portanto, não imprimirá “hello, world”.
 O fato interessante é que até poucos anos atrás não se sabia se este programa iria
ou não imprimir “hello, world” para algum inteiro grande n.

int exp(int i, n)
/* calcula i elevado a n */
{
int ans, j;
ans = 1;
for (j=1; j<=n; j++) ans *= i;
return(ans);
}
main ()
{
int n, total, x, y, z;
scanf(“%d”, &n);
total = 3;
while (1) {
for (x=1; x<=total-2; x++)
for (y=1; y<=total-x-1; y++) {
z = total – x – y;
if (exp(x,n)+exp(y,n)==exp(z,n))
printf(“hello, worldn”);
}
total++;
}
}

7.2. Um Problema Parcialmente Computável
 Intuitivamente uma função é dita computável se é possível calcular seu valor,
dado qualquer elemento do seu domínio.
 Toda função bem definida é computável?
read x;
while x ≠ 10 do
x := x + 1;
print x;
end;
 Note que o programa acima não pára caso x > 10.
 Uma função é parcialmente computável se é possível calcular seu valor para
apenas alguns elementos do seu domínio de definição.
 O exemplo acima é parcialmente computável.

7.3. O Problema da Parada (The Halting Problem)
 Os computadores possuem uma capacidade de resolução de problemas tão grande
que, às vezes, podemos imaginar que qualquer problema pode ser resolvido por
um computador.
 Entretanto, através de um exemplo importante é possível mostrar que os
computadores são limitados de uma maneira fundamental.
 Nesta seção vamos discutir um dos teoremas mais importantes filosoficamente em
teoria da computação:
o Existe um problema específico que não pode ser resolvido por um algoritmo.
 Em um tipo de problema não-resolvível, tem-se um programa computacional e
uma especificação precisa do que este programa deve fazer (p. ex. ordenar uma
lista de números).
o É preciso verificar se este programa se comporta como especificado, ou seja,
se está correto.

 Como tanto o programa quanto a especificação são objetos matemáticos precisos,
é intuitivo que o processo de verificação possa ser automatizado dados o programa
e a especificação como entradas para um computador.
o Entretanto, o problema genérico de verificação se um software se comporta
como desejado não é resolvível por um computador.
 Um problema importante que demonstra a não decidibilidade de uma linguagem
específica é o problema de testar se uma máquina de Turing aceita uma dada
sentença de entrada, ou seja, se dada uma sentença de entrada a MT irá parar.
o Este problema é conhecido como problema da parada.
 Seja:
ATM = {M,w | M é uma MT que aceita w}.
 Teorema 1:
ATM não é decidível.
 Antes de provar o Teorema 1, observe que ATM é Turing-reconhecível.

o Este teorema mostra, portanto, que reconhecedores são mais poderosos que
decisores.
o Exigir que a MT pare para todas as entradas restringe os tipos de linguagens
que ela pode reconhecer.
 A seguinte MT reconhece ATM:
Dada a entrada M,w, onde M é uma MT e w é uma sentença
1. Simule M para a entrada w.
2. Se M entrar em um estado aceito, aceite; se M entrar em um estado rejeitado,
rejeite.
 Nota 1: esta máquina entra em loop para a entrada M,w se M entrar em loop para
w, razão pela qual esta máquina não decide ATM.
 Nota 2: se o algoritmo tivesse alguma forma de determinar que M não iria parar
dado w, ele poderia rejeitar.
o Nenhum algoritmo pode determinar se uma máquina irá parar de executá-lo!

Prova: Vamos assumir que ATM é decidível e obter uma contradição. Suponha que H
seja um decisor para ATM. Dada a entrada M,w, H para e aceita se M aceita w. Além
disso, H para e rejeita se M não aceita w. Em outras palavras, assumimos que H é
uma MT, onde




wMrejeita
wMaceita
wMH
aceitanãose
aceitase
),(
Agora vamos construir uma nova MT D com H sendo uma sub-rotina. Esta nova MT
chama H para determinar o que M faz quando a entrada para M é sua própria
descrição M. Uma vez que D determinou esta informação, ela executa o oposto; ou
seja, ela rejeita se M aceita e aceita se M rejeita:
D = “Para a entrada M, onde M é uma MT:
Execute H para a entrada M,M.
Apresente na saída o oposto da saída de H; ou seja, se H aceita, rejeite, e se H
rejeita, aceite.”

Em resumo:




MMrejeita
MMaceita
MD
aceitase
aceitanãose
)(
Ao executar D com sua própria descrição D na entrada:




DDrejeita
DDaceita
DD
aceitase
aceitanãose
)( .
 Não importa o que D faz, ele é sempre forçado a fazer o oposto, que é obviamente
uma contradição. Portanto, nem D nem H podem existir.
Obs.: executar uma máquina em sua própria descrição é similar a executar um
programa tendo ele próprio como entrada. Por exemplo, um compilador é um
programa que ‘traduz’ outros programas.

7.4. O Problema da Correspondência de Post
 O problema da correspondência de Post (PCP – Post-Correspondence Problem)
pode ser descrito como um jogo de dominós.
 Seja um conjunto de dominós, cada um contendo duas sentenças sendo uma de
cada lado:






























c
abc
a
ca
ab
a
ca
b
,,,
 A tarefa consiste em fazer uma lista destes dominós (repetições são permitidas) de
forma que a sentença obtida lendo-se os símbolos da parte superior seja a mesma
da sentença obtida lendo-se os símbolos da parte inferior.
o Esta lista é denominada de casamento ou match.
Exemplo:


























c
abc
ab
a
a
ca
ca
b
ab
a
,,,,

 Para algumas coleções de dominós pode não ser possível encontrar um casamento.
Exemplo:


















ba
acc
a
ca
ab
abc
,,
A coleção acima não pode conter um casamento, pois todas as sentenças da parte
superior são mais compridas do que as sentenças da parte inferior.
 O problema PCP consiste em determinar se uma coleção de dominós possui um
casamento.
o Este problema não pode ser resolvido por um algoritmo.
 Antes de discutir a ideia da prova, vamos descrever o problema precisamente e
expressá-lo como uma linguagem.
 Uma instância do problema PCP é uma coleção P de dominós:


























k
k
b
t
b
t
b
t
P ,...,,
2
2
1
1
,
e um casamento é uma sequência i1, i2,..., il, onde ti1, ti2,..., til = bi1, bi2,..., bil.
 O problema consiste em determinar se P possui um casamento. Seja:
PCP = {P | P é uma instância do problema da correspondência de Post com um
casamento}
 Teorema 2:
PCP é indecidível.
Ideia da Prova: Conceitualmente a prova é simples, embora ela apresenta vários
detalhes técnicos.
A principal técnica é uma redução da linguagem ATM através da aceitação de
históricos da computação.

É possível mostrar que a partir de uma MT M qualquer e de uma entrada w,
podemos construir uma instância P onde um casamento é um histórico de uma
computação que resulta em um estado aceito para M dada w.
Se for possível mostrar se a instância possui um casamento, então é possível
determinar se M aceita w.
8. Problemas Decidíveis Envolvendo Linguagens Regulares
 Nesta seção apresentaremos exemplos de linguagens que são decidíveis por
algoritmos.
 Inicialmente apresentaremos algoritmos para testar:
o Se um autômato finito aceita uma sentença;
o Se uma linguagem de um autômato finito é vazia; e
o Se dois autômatos são equivalentes.

 Por conveniência usaremos linguagens para representar vários problemas
computacionais, uma vez que já definimos uma terminologia para tratar
linguagens.
o Por exemplo, o problema de aceitação para autômatos finitos determinísticos
(AFD), que testa se um determinado AFD aceita uma dada sentença pode ser
expresso como uma linguagem AAFD.
o Esta linguagem contém a codificação de todos os AFDs junto com as
sentenças que eles aceitam.
o Seja:
AAFD = {B,w | B é um AFD que aceita a sentença de entrada w}.
O problema de testar se um AFD B aceita uma sentença w é equivalente a
testar se B,w é um membro da linguagem AAFD.
o De maneira similar, é possível formular outros problemas computacionais
como problemas de pertinência a uma linguagem.

o Mostrar que uma linguagem é decidível é equivalente a mostrar que um
problema computacional é decidível, ou seja, é resolvível por um algoritmo.
 Teorema 3:
o AAFD é uma linguagem decidível.
Idéia da prova: apresentar uma máquina de Turing que decida AAFD.
M = “dada uma entrada B,w, onde B é um AFD e w uma sentença:
1. Simule B para a entrada w.”
2. Se a simulação terminar em um estado aceito (qaccept), aceite.
3. Se terminar em um estado não aceito, rejeite.”
Prova: vamos mencionar apenas alguns detalhes de implementação desta prova.
Primeiro, examine a entrada B,w. Ela é a representação de um AFD B e de
uma entrada w. Uma representação razoável de B é simplesmente uma lista com
seus cinco componentes: Q, , , q0 e F. Quando M recebe sua entrada, ela

primeiramente checa se a entrada representa apropriadamente um AFD B e uma
entrada w. Caso negativo, rejeite.
Em seguida, M simula o AFD B diretamente. Ela acompanha o estado atual de
B e a posição da entrada w, escrevendo estas informações na fita. Inicialmente o
estado de B é q0 e a posição de entrada é o símbolo mais a esquerda de w. Os
estados e a posição são atualizados de acordo com uma função de transição
específica . Quando M acaba de processar o último símbolo de w, M aceita a
entrada se B está em um estado aceito; M rejeita a entrada se B está em um
estado rejeitado.
 É possível provar um teorema similar para um autômato finito não-determinístico
AFN.

 Seja:
AAFN = {B,w | B é um AFN que aceita a sentença de entrada w}.
 Teorema 4:
o AAFN é uma linguagem decidível.
Prova: vamos apresentar uma máquina de Turing N que decida AAFN.
o É possível projetar N para operar como M, simulando um AFN ao invés de
um AFD. Ao invés disso, façamos N usar M como uma sub-rotina.
o Como M é projetado para operar com AFDs, N primeiramente converte o
AFN recebido como entrada em um AFD antes de passá-lo para M.
N = “dada uma entrada B,w, onde B é um AFN e w uma sentença:
1. Converta o AFN B em seu equivalente AFD C usando um procedimento
para conversão.
2. Rode a MT M do Teorema 1 para a entrada C,w.
3. Se M aceitar, aceite; senão rejeite.”

 Rodar a MT M no procedimento acima significa incorporar M no projeto de N
como um sub procedimento.
 De forma similar, é possível testar se uma expressão regular gera uma dada
sentença.
 Seja:
AER = {R,w | R é uma expressão regular que gera a sentença w}.
 Teorema 5:
o AER é uma linguagem decidível.
Prova: a seguinte máquina de Turing P decide AER.
P = “dada uma entrada R,w, onde R é uma ER e w uma sentença:
1. Converta a expressão regular R no AFD A equivalente usando o
procedimento para conversão dado anteriormente.
2. Rode a MT M para a entrada A,w.
3. Se M aceitar, aceite; se M rejeitar, rejeite.

 Os Teoremas 3, 4 e 5 ilustram que, para propósitos de decidibilidade, apresentar
uma máquina de Turing com um AFD, um AFN ou uma ER é sempre equivalente,
pois a MT é capaz de converter uma forma de codificação por outra.
 Vamos estudar agora outro tipo de problema em relação aos autômatos finitos: o
problema de testar se uma linguagem de um autômato finito é vazia.
 Nos teoremas anteriores foi necessário testar se um autômato finito aceita uma
determinada sentença. Na próxima prova testaremos se um autômato finito aceita
pelo menos uma sentença.
 Seja:
EAFD = {A | A é um AFD e L(A) = }.
 Teorema 6:
EAFD é uma linguagem decidível.
Prova: um AFD aceita alguma sentença se, e somente se, for possível atingir
um estado aceito a partir do estado inicial seguindo as setas do AFD.

Para testar esta condição é possível projetar uma MT T que usa um algoritmo de
marcação.
T = “dada uma entrada A, onde A é um AFD:
1. Marque o estado inicial A;
2. Repita até que nenhum novo estado seja marcado:
a. Marque qualquer estado que possui uma transição vindo para ele de
qualquer estado que já está marcado.
3. Se nenhum estado aceito está marcado, aceite; senão, rejeite.
 Por último vamos verificar a decidibilidade de AFDs equivalentes, ou seja, se dois
autômatos são equivalentes.
 O próximo teorema mostra que testar se dois AFDs reconhecem a mesma
linguagem é um problema decidível.
 Seja:
EQAFD = {A,B | A e B são AFDs e L(A) = L(B)}.

 Teorema 7:
EQAFD é uma linguagem decidível.
Prova: Para provar este teorema usaremos o Teorema 6.
Construa um novo AFD C a partir de A e B, onde C aceita apenas aquelas
sentenças que são aceitas ou por A ou por B, mas não por ambos. Assim, se A e
B reconhecem a mesma linguagem, C não aceitará nada.
A linguagem de C é:
   .)()()()()( BLALBLALCL 
Esta expressão é conhecida como diferença simétrica de L(A) e L(B).

Figura 8: Diferença simétrica entre L(A) e L(B).
 A diferença simétrica é útil aqui, pois L(C) =  se e somente se L(A) = L(B).
 É possível construir C a partir de A e B com as construções para provar a classe de
linguagens regulares fechadas sob o complemento, união e interseção.
o Estas construções são algoritmos que podem ser executados por uma MT.
o Uma vez que C foi construído é possível usar o Teorema 4 para testar se L(C)
é vazia. Se for, então L(A) = L(B).
L(A) L(B)

F = “dada uma entrada A,B, onde A e B são AFDs:
1. Construa um AFD C como descrito;
2. Rode a MT T do Teorema 4 para a entrada C;
3. Se T aceitar, aceite; senão, rejeite.”
9. Problemas Decidíveis Envolvendo Linguagens Livres de
Contexto
 Nesta seção vamos descrever algoritmos para testar se uma gramática livre de
contexto (GLC) gera uma sentença particular e se uma linguagem de uma GLC é
vazia.
 Seja:
AGLC = {G,w | G é uma GLC que gera w}.
 Teorema 8:
AGLC é uma linguagem decidível.

Idéia da Prova: Para a GLC G e a sentença w queremos testar se G gera w. Uma
ideia é usar G para percorrer todas as derivações para determinar se alguma delas
é uma derivação de w. Esta ideia não funciona pois infinitas derivações podem ter
que ser testadas. Se G não gerar w, então este algoritmo nunca irá parar. Esta ideia
faz com que a MT seja um reconhecedor, mas não um decisor, da linguagem
AGLC.
Para tornar esta MT um decisor é preciso garantir que o algoritmo irá testar apenas
uma quantidade finita de derivações. Já vimos que se G estiver na forma normal
de Chomsky, qualquer derivação de w possui 2n  1 passos, onde n é o
comprimento de w. Neste caso, checar somente derivações com 2n  1 passos para
determinar se G gera w seria suficiente. Somente uma quantidade finita destas
derivações existe. É possível converter G para a forma normal de Chomsky.
Prova: A MT S para AGLC é:
S = “dada uma entrada G,w, G é uma GLC e w é uma sentença:

o Converta G em sua gramática equivalente na forma normal de Chomsky;
o Liste todas as derivações com 2n  1 passos, onde n é o comprimento de w;
exceto se n = 0, caso no qual todas as derivações de um passo são listadas;
o Se alguma destas derivações gerar w, aceite; senão, rejeite.
 Vamos considerar agora o problema de testar se uma linguagem de uma GLC está
vazia.
 Como feito para um AFD, é possível mostrar que o problema de testar se uma
GLC gera uma sentença qualquer é decidível.
 Seja:
EGLC = {G | G é uma GLC e L(G) = }.
 Teorema 9:
EGLC é uma linguagem decidível.
Idéia da Prova: Para testar se uma linguagem de uma gramática está vazia, é
preciso testar se a variável inicial pode gerar uma sentença de terminais. O

algoritmo faz isso resolvendo um problema ainda mais genérico. Ele determina
para cada variável se aquela variável é capaz de gerar uma sentença de terminais.
Quando o algoritmo determinou que uma variável pode gerar alguma sentença de
terminais, o algoritmo mantém esta informação marcando aquela variável.
Primeiro o algoritmo marca todos os símbolos terminais da gramática. Depois ele
lê todas as regras da gramática. Se ele encontrar uma regra que permita alguma
variável ser substituída por alguma sentença de símbolos já marcada, o algoritmo
sabe que esta variável também pode ser marcada. O algoritmo procede desta
forma até que ele não possa mais marcar nenhuma variável adicional. A MT R
implementa este algoritmo.
Prova:
R = “dada uma entrada G, onde G é uma GLC:
o Marque todos os símbolos terminais de G;
o Repita até que nenhuma nova variável possa ser marcada:

 Marque qualquer variável A onde G tenha uma regra A  U1U2...Uk e
cada símbolo U1,...,Uk já tenha sido marcado.
o Se o símbolo inicial não estiver marcado, aceite; senão, rejeite.
 Finalmente, vamos considerar o caso de testar se duas gramáticas livres de
contexto geram a mesma linguagem.
 Seja:
EQGLC = {G,H | G e H são GLCs e L(G) = L(H)}.
 Teorema 10:
Toda linguagem livre de contexto (LLC) é decidível.
Prova: Seja G uma GLC para A e projete uma MT MG que decide A. Construa
uma cópia de G em MG. Funciona como a seguir:
MG = “para a entrada w:
o Rode a MT S para a entrada G,w
o Se esta MT aceitar, aceite; senão, rejeite.”

 O Teorema 8 fornece a última ligação entre as quatro principais classes de
linguagens: regular, livre de contexto, decidível e Turing reconhecível.
Regular
Livre de
contexto Decidível Turing
Reconhecível
Figura 9: Relação entre as classes de linguagens.

Tópico 3: Complexidade Computacional
10. Introdução
 Mesmo quando um problema é decidível e, portanto, computacionalmente
resolvível, ele pode não ser resolvível na prática se sua solução requer uma
quantidade excessivamente alta de tempo de processamento e memória.
 Neste tópico a teoria de complexidade computacional será estudada como uma
investigação do tempo computacional necessário para a resolução de um
determinado problema.
 A discussão a ser apresentada aqui levanta uma distinção importante entre teoria
de complexidade e teoria de computabilidade:
o Na teoria de computabilidade, a tese de Church-Turing implica que todo
modelo razoável de computação é equivalente entre si, ou seja, todos eles
decidem a mesma classe de linguagens.

o Em teoria de complexidade a escolha do modelo afeta a complexidade temporal
das linguagens.
 Neste tópico ficará mais clara a relação entre aceitar e rejeitar uma linguagem
(problema) e a resolução de um problema.
11. Medindo a Complexidade
 Exemplo 1:
o Dada uma linguagem decidível A = {0k
1k
| k  0}, quanto tempo uma MT
simples (de fita única) precisa para decidir esta linguagem?
o Seja uma MT M1 para A. Vamos descrever M1 em baixo nível para que
possamos contar o número de passos que M1 usa quando é executada.
M1 = Dada a sentença de entrada w:
1. Leia a fita e rejeite se um 0 for encontrado a direita de um 1.
2. Repita o passo abaixo se ambos 0s e 1s permanecem na fita.
a. Leia a fita, ‘cortando’ um único 0 e um único 1.

3. Se ainda restar algum 0 após todos os 1s serem cortados, ou se ainda
restar algum 1 após todos os 0s serem cortados, rejeite. Caso contrário, se
nenhum 0 ou 1 permanecer na fita, aceite. 
 Vamos analisar quanto tempo leva o algoritmo da MT M1 para decidir A.
 A quantidade de passos que um algoritmo usa para uma determinada entrada pode
depender de vários parâmetros. Por exemplo, se a entrada for um grafo, então o
número de passos pode depender do número de nós, do número de arcos ou de
alguma combinação destes e outros fatores.
 Por simplicidade, é usual calcular o tempo computacional de um algoritmo
baseado no comprimento de sua sentença de entrada ou da instância do problema.
 Na análise de pior caso, adotada aqui, é considerado o maior tempo possível para
todas as entradas de um determinado comprimento.
 Na análise do caso médio, a média de todos os tempos de execução das entradas
de um determinado comprimento é considerada.

 Definição 1:
Seja M uma máquina de Turing determinística que pára dada qualquer entrada. O
tempo de execução ou complexidade de tempo de M é a função f : N  N, onde
f(n) é o número máximo de passos que M usa para qualquer entrada de
comprimento n ou para qualquer instância de tamanho n de um determinado
problema. Se f(n) é o tempo de execução de M, diz-se que M executa (roda) em
um tempo f(n) e que M é uma MT de tempo f(n). 
11.1. A Notação Big-O.
 Como o tempo de execução exato de um algoritmo é geralmente uma expressão
complexa, seu valor é usualmente apenas estimado.
 Em uma forma conveniente de estimação, denominada de análise assintótica, é
feita uma estimativa do tempo de execução do algoritmo quando ele é executado
para entradas grandes.

o Neste caso é considerado apenas o termo de maior ordem da expressão que
determina o tempo de execução do algoritmo, desconsiderando tanto o
coeficiente deste termo quanto os termos de menor ordem. Isso é feito porque o
termo de maior ordem domina os outros para valores grandes de entrada.
 Exemplo 2:
A função f(n) = 6n3
+ 2n2
+ 20n + 45 possui quatro termos, e o termo de maior
ordem é 6n3
.
Desconsiderando o coeficiente 6, diz-se que f é assintoticamente no máximo n3
.
A notação assintótica ou notação Big-O para descrever esta relação é f(n) = O(n3
).

0 1000 2000 3000 4000 5000 6000 7000 8000 9000 10000
10
0
10
2
10
4
10
6
10
8
10
10
10
12
10
14
6n3
+ 2n2
+ 20n + 45
n3
Figura 10: Comportamento assintótico da função do Exemplo 2. 

 Definição 2:
Sejam f e g duas funções f,g: N  +
, onde +
é o conjunto dos reais maiores que
zero. Diz-se que f(n) = O(g(n)) se existem inteiros positivos c e n0 tais que para
cada inteiro n  n0
f(n)  c.g(n).
Quando f(n) = O(g(n)) diz-se que g(n) é um limite superior para f(n), ou mais
precisamente, que g(n) é um limite superior assintótico para f(n), enfatizando
assim que fatores constantes estão sendo suprimidos. 
 Exemplo 3:
Seja f1(n) = 5n3
+ 2n2
+ 25n + 6.
Selecionando o termo de maior ordem, 5n3
, e desprezando seu coeficiente, tem-se
f1(n) = O(n3
). 

Prova formal:
Sejam c = 6 e n0 = 10.
Então 5n3
+ 2n2
+ 22n + 6  6n3
,  n  10.
Além disso, pode-se dizer que f1(n) = O(n4
) pois n4
> n3
e, portanto, ainda é um
limite superior para f1. O menor limitante superior de f1 é O(n3
).
Entretanto, f1(n)  O(n2
), pois independentemente dos valores especificados para c
e n0 a definição permanece não satisfeita. 
 A notação Big-O interage com logaritmos de forma muito particular.
o Geralmente ao usar logaritmos devemos especificar a base:
x = log2 n  2x
= n.
o Mudando a base b, muda o valor do logaritmo por um fator constante log2 b:
logb n = log2 n / log2 b.
o Assim, quando escrevemos f(n) = O(log n), especificamos que a base não é
mais necessária, pois um fator constante está sendo suprimido.

 Exemplo 4:
Seja f2(n) = 3n log2n + 5n log2 log2 n + 2.
Neste caso tem-se: f2(n) = O(n log n), pois log n domina log log n. 
 A notação Big-O também aparece em expressões aritméticas como, por exemplo,
f(n) = O(n2
) + O(n).
o Neste caso, cada ocorrência do símbolo O representa uma constante diferente
suprimida.
o Como o termo O(n2
) domina o termo O(n), a expressão ilustrada acima é
equivalente a f(n) = O(n2
).
 É frequente derivar limites superiores da forma nc
, c > 0. Estes limites são
denominados limites polinomiais. Limites da forma cn
, c > 1, são denominados de
limites exponenciais.

1 2 3 4 5 6 7 8 9 10
0
200
400
600
800
1000
1200
2n
n2
n
0 10 20 30 40 50 60 70 80 90 100
0
1
2
3
4
5
6
7
log2 n
(a) (b)
Figura 11: (a) Crescimentos exponencial e polinomial. (b) Crescimento logarítmico.
EPC 7: Um algoritmo precisa de 0,5ms para executar uma entrada de tamanho 100.
Quanto tempo ele precisará para uma entrada de tamanho 500 se seu tempo de
execução for:
a) Linear. b) O(n log n). c) Quadrático. d) Cúbico.

EPC 8: Ordene (ordem crescente) as seguintes funções pela taxa de crescimento: n,
n 1/2
, (n)1.5
, n2
, n log n, n log log n, n log2
n, n log (n2
), 2/n, 2n
, 2n/2
, 37, n3
, n2
log n.
EPC 9: Determine a ordem de complexidade, na notação big-O, de cada uma das
funções abaixo:
a) 5n4
+ 3n3
+ 2n2
+ 4n + 1. b) 5n2
+ 3n log n + 2n + 5.
c) 20n3
+ 10n log n + 5. d) 2 + 3 log n.
e) 2n+2
. f) 2n + 100 log n.
11.2. Análise de Algoritmos
 Para descrever um algoritmo é preciso seguir algumas convenções tal que eles
possam ser analisados.
 Os algoritmos geralmente são descritos por estágios, de forma análoga aos passos
de uma MT.
 Para analisar um algoritmo é necessário fazer duas coisas:

2015: Fundamentos Teóricos da Computação

2015: Fundamentos Teóricos da Computação

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a 2015: Fundamentos Teóricos da Computação

Semelhante a 2015: Fundamentos Teóricos da Computação (20)

Mais de Leandro de Castro

Mais de Leandro de Castro (11)

Último

Último (8)

2015: Fundamentos Teóricos da Computação