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.

http://www.slideshare.net/lndecastro

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 i0 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}):



(01)0* (01)*

(0*)(*1) 0*10*

*0*1 1001

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) = {anbm | n 0, m 1}

b) L(G) = {anb2n | 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…xk1qxkxk+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…xk1qxkxk+1…xm├M x1…xk2pxk1yxk+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 i1 (k1).

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…pxm1

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…xk1qxkxk+1…xm├M x1…xk1ypxk+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…xm1qxm├M x1…xm1yp#

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, world\n”);

}

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, world\n”);

}

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

wMaceitawMH

aceita não se

aceita se),(

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

MMaceitaMD

aceita se

aceita não se)(

Ao executar D com sua própria descrição D na entrada:

DDrejeita

DDaceitaDD

aceita se

aceita não se)( .

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

tP ,...,,

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 = {0k1k | 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 + 2n

2 + 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:



o Fornecer um limite superior, geralmente expresso usando a notação Big-O,

para o número de estágios que o algoritmo usa quando executado para uma

entrada ou instância de tamanho n.

o Determinar o custo computacional de cada estágio individual da descrição do

algoritmo.

Também é preciso levar em consideração a codificação para o problema. Por

exemplo, um grafo pode ser codificado como uma lista de nós e ramos.

Exemplo 5:

Vamos analisar o algoritmo dado para a linguagem A = {0k1k | k 0}:

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.



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.

Para analisar M1 vamos considerar cada um de seus três estágios separadamente.

o Estágio 1: 2n passos (mover o cabeçote para a direita e depois para a esquerda).

Custo: O(n).

o Estágio 2: n/2 passos para ler todos os pares de 0s e 1s mais O(n) de custo para

cada leitura da fita. Custo: (n/2)O(n) = O(n2).

o Estágio 3: uma leitura da fita é feita para decidir se a MT aceita ou rejeita.

Custo: O(n).

Custo total: O(n) + O(n2) + O(n).

o Portanto, Custo = O(n2).



Definição 3:

Seja t : N N uma função. A classe de complexidade de tempo, TIME(t(n)), é

definida como sendo:

TIME(t(n)) = {L | L é uma linguagem decidível por uma MT com custo O(t(n))}.

Exemplo 6:

Para a linguagem A = {0k1k | k 0} a análise anterior mostra que A TIME(n2)

pois M1 decide A em tempo O(n2) e TIME(n2) contém todas as linguagens que

podem ser decididas em um tempo O(n2).

Veremos agora que é possível projetar algoritmos mais eficientes sob o ponto de

vista de tempo de processamento (complexidade).

Para o exemplo dado, estudaremos um algoritmo capaz de reduzir o esforço

computacional necessário para decidir A.

Exemplo 7:

o Seja uma MT M2 para A.





2. Leia a fita, e verifique se o número total de 0s e 1s que permanece na fita

é par ou ímpar. Se for ímpar, rejeite.

3. Repita o passo abaixo enquanto algum 0 ou 1 permanecer na fita.

a. Leia a fita novamente, cortando metade dos 0s que começam com

o primeiro 0 e depois cortando metade dos 1s que começam com o

primeiro 1.

4. Se nenhum 0 ou 1 permanecer na fita, aceite. Caso contrário, rejeite.

Ao analisar o custo computacional de M2, verificamos que cada estágio requer um

tempo O(n).

Em seguida é preciso determinar quantas vezes cada estágio é executado.

o Os Estágios 1 e 3 são executados uma única vez, demandando um total de

tempo O(n).



o O Estágio 2.a tem custo O(n).

o O Estágio 2.b corta metade dos 0s e 1s cada vez que é executado. Assim, no

máximo 1 + log2 n iterações ocorrem antes que todos sejam cortados.

Assim, o tempo total é O(n) + (1+log2 n)O(n) ou O(n log n).

Portanto o custo de M2 é O(n log n).

Sendo assim, é possível mostrar que A TIME(n log n).

Embora o resultado acima não possa ser melhorado para uma máquina de Turing

de uma única fita, é possível melhorá-lo usando uma MT com duas fitas.

Neste caso é possível decidir a linguagem A em tempo O(n), também denominado

de tempo linear.

Exemplo 8:

o Seja uma MT M3 com duas fitas para A.





2. Leia todos os 0s da Fita 1 até encontrar o primeiro 1. Ao mesmo tempo

copie os 0s para a Fita 2.

3. Leia todos os 1s da Fita 1 até o final da entrada. Para cada 1 lido na Fita 1,

corte um 0 da Fita 2. Se todos os 0s da Fita 2 estiverem cortados antes que

todos os 1s sejam lidos, rejeite.

4. Se todos os 0s foram cortados, aceite. Se algum 0 permanecer, rejeite.

Analisando este algoritmo é fácil perceber que cada um de seus quatro estágios

usa O(n) passos, portanto o tempo total de execução é O(n) e, portanto, linear.

o Note que este é o melhor tempo possível, pois ele é o mínimo necessário para

ler todas as entradas.

Em teoria de complexidade um dos objetivos é classificar problemas

computacionais de acordo com o tempo necessário para encontrar uma solução

para eles.



o Entretanto, como vimos o custo computacional depende do modelo de solução

empregado.

EPC 10: Para cada um dos programas abaixo faça: a) Forneça a análise de

complexidade; b) Implemente o código e execute para diversos valores de n; c)

Compare sua análise teórica com os tempos reais de execução.

for (int i = 0; i < n; i++) (a)

sum++;

for (int i = 0; i < n; i++) (b)

for (int j = 0; j < n; j++) sum++;

for (int i = 0; i < n; i++) (c) sum++; for (int j = 0; j < n; j++) sum++;

for (int i = 0; i < n; i++) (d) for (int j = 0; j < n * n; j++)



sum++;

for (int i = 0; i < n; i++) (e) for (int j = 0; j < i; j++)

sum++;

for (int i = 0; i < n; i++) (f) for (int j = 0; j < n * n; j++) for (int k = 0; k < j; k++)

sum++;

EPC 11: Considere o problema de fazer o cálculo das médias pré-fixadas de uma

sequência de números, ou seja, dispondo de um arranjo X armazenando n números,

deseja-se compor um arranjo A tal que A[i] seja a média dos elementos X[0], ... , X[i]

para i = 0, ... , n = 1:

1

][

][0

i

jX

iA

i

j

Os algoritmos (a) e (b) abaixo podem ser usados para resolver este problema. Faça a

análise de complexidade de tempo de cada um deles e compare.



Algoritmo (a)

Algoritmo prefixAverages1(X)

Entrada: um arranjo X com n elementos

Saída: um arranjo A com n elementos tal que A[i] é a média de X[0], ... , X[i].

Seja A um arranjo de n números

para i 0 até n 1 faça

a 0

para j 0 até i faça

a a + X[j]

A[i] a/(i+1)

Retorne A

Algoritmo (b)

Algoritmo prefixAverages2(X)

Entrada: um arranjo X com n elementos

Saída: um arranjo A com n elementos tal que A[i] é a média de X[0], ... , X[i].

Seja A um arranjo de n números

s 0

para i 0 até n 1 faça

s s + X[i]

A[i] s/(i+1)



Retorne A

EPC 12: Um problema clássico em computação consiste em ordenar um conjunto de

números. Assumindo uma ordenação crescente, os dois algoritmos abaixo podem ser

usados para esta tarefa (Bubble sort e Quick sort). Para estes algoritmos faça: a)

Forneça a análise de complexidade; b) Implemente o código e execute para diversos

conjuntos aleatórios de diferentes tamanhos (n); c) Compare sua análise teórica com

os tempos reais de execução.

Algoritmo (a) Algoritmo bubblesort(x)

Entrada: um vetor x com n elementos a serem ordenados

Saída: o vetor x ordenado

Determine o comprimento n do vetor

para k 0 até n 1 faça

para j 0 até n k faça

se x(j) > x(j + 1) então

troque x(j) e x(j + 1)

Retorne x

Algoritmo (b) O algoritmo Quick Sort, a ser apresentado a seguir, é um algoritmo recursivo que opera da

seguinte forma:

1. Selecione um elemento x(p) de x



2. Divida x em duas partes x1 e x2 de forma que todos os elementos de x1 x(p) e todos

os elementos de x2 x(p). Para finalizar ordene x1 e x2.

3. Aplique os passos 1 e 2 a cada x1 e x2 usando novas subdivisões.

4. Repita estes passos recursivamente até que os conjuntos a serem ordenados não

tenham mais elementos.

11.3. Relações de Complexidade entre Modelos

Nesta seção vamos investigar como a escolha do modelo computacional pode

afetar a complexidade das linguagens.

Vamos considerar três modelos:

o Máquinas de Turing de uma única fita

o Máquinas de Turing de múltiplas fitas

o Máquinas de Turing não-determinísticas

Teorema 1:

Seja t(n) uma função, onde t(n) n. Toda MT de múltiplas fitas com tempo t(n)

possui uma MT de única fita equivalente com custo O(t2(n)).



Idéia da Prova: Para provar este teorema é preciso mostrar como simular uma MT

de múltiplas fitas usando uma MT de fita única e analisar esta simulação.

Prova: Seja M uma MT de k fitas que roda em t(n) passos. Vamos construir uma

MT S de fita única que roda em um tempo O(t2(n)).

Simulando M com S.

S usa uma única fita para representar o conteúdo de todas as k fitas de M. As fitas são

armazenadas consecutivamente, com as posições dos cabeçotes de M marcadas em

células apropriadas. Inicialmente S coloca sua fita no formato que representa todas as

fitas de M e depois executa os passos de M. Para simular um passo, S lê toda a

informação armazenada em sua fita para determinar os símbolos sobre o cabeçote de

M. Depois S executa uma outra passagem sobre sua fita para atualizar o conteúdo da

fita e posições do cabeçote.

Análise:



Para cada passo de M, S executa dois passos sobre a porção ativa de sua fita. O

primeiro obtém a informação necessária para determinar o próximo passo e o

segundo executa a informação. Uma leitura da porção ativa da fita de S usa O(t(n))

passos. Para simular cada passo de M, S faz duas leituras e possivelmente até k

movimentos para a direita. Cada um possui custo O(t(n)), portanto, o tempo total

para S simular um dos passos de M é O(t(n)).

O estágio inicial de colocar a fita de S de forma apropriada usa O(n) passos.

Depois S simula cada um dos t(n) passos de M, usando O(t(n)) passos. Assim, esta

parte da simulação demanda t(n)O(t(n)) = O(t2(n)) passos.

Portanto, toda a simulação requer O(n) + O(t2(n)) = O(t2(n)) passos.

Definição 4:

Seja ND uma MT não-determinística que é um decisor. O tempo de execução de ND

é a função f : N N, onde f(n) é o número máximo de passos que ND usa em

qualquer ramo de sua computação para qualquer entrada de comprimento n.



.

.

.

.

.

. Rejeita

Aceita

Determinística Não-Determinística

f(n) f(n)

Figura 12: Medindo o tempo determinístico e não-determinístico.

Teorema 2:

Seja t(n) uma função, onde t(n) n. Toda MT não-determinística de única fita

possui uma MT determinística de única fita equivalente com custo 2O(t(n)).

Prova: ver Sipser, p. 233-234.



12. A Classe P

Os Teoremas 1 e 2 ilustram distinções importantes:

o Há uma diferença polinomial (quadrática) entre a complexidade de tempo de

problemas medidos em MT determinísticas de uma única e múltiplas fitas.

o Há uma diferença exponencial entre a complexidade de tempo de problemas

medidos em MT determinísticas e não-determinísticas.

Diferenças polinomiais de tempo de processamento são consideradas pequenas, e

diferenças exponenciais são consideradas grandes (Figura 11).

Exemplo 9:

Considere a taxa de crescimento de um polinômio n3 e de uma exponencial 2n.

Seja n = 1000. Neste caso, n3 = 1109 e 2n é um número muito maior que a

quantidade de átomos do universo.



Algoritmos com custo exponencial geralmente surgem quando resolvemos

problemas através de uma busca exaustiva pelo espaço de soluções, chamada de

busca por força bruta.

o A filosofia de um algoritmo de busca exaustiva é analisar todas as possíveis

soluções para um determinado problema.

o Exemplo: o problema de fixação de componentes apresentado.

Exemplo 10:

Um número primo é um número que é divisível apenas por ele próprio e por 1.

Exemplo: 2, 3, 5, 7, 11, ...

Qualquer número inteiro não primo pode ser encontrado multiplicando seus fatores

primos. Exemplo: 33 = 3 11.



Uma forma de fatorar um número em seus fatores primos é buscar todos os

possíveis divisores deste número.

Neste caso o tamanho do espaço de busca é exponencial.

EPC 13: Encontre os fatores primos dos seguintes números: 49, 129, 273, 1293.

Os métodos de força bruta podem muitas vezes ser evitados através de um

conhecimento mais profundo do problema ou da utilização de técnicas (heurísticas

ou informadas) mais eficientes. Em muitos casos, algoritmos polinomiais de

solução podem ser projetados.

Todo modelo computacional razoável possui complexidade polinomial.

Definição 4:

P é a classe de linguagens decidíveis em tempo polinomial por uma máquina de

Turing determinística de fita única:



P = kTIME(nk).

A classe P possui um papel fundamental em teoria de complexidade e é

importante por duas razões:

o P é invariante para todos os modelos de computação que são

polinomialmente equivalentes a uma MT determinística de fita única; e

o P corresponde a classe de problemas que são mais facilmente resolvíveis por

um computador utilizando técnicas tradicionais de solução.***

12.1. Exemplos de Problemas em P

Vamos considerar aqui alguns problemas que podem ser representados por um

grafo.

Exemplo 11:

Seja PATH o problema de determinar se existe um caminho ligando os nós s e t de

um grafo direcionado:



PATH = {G,s,t | G é um grafo direcionado que possui um caminho direto de s

para t}.

s

t

Figura 13: Exemplo de um grafo que possui um caminho (PATH) de s para t.

Teorema 3:

O problema PATH P.

Idéia da Prova: É possível provar este teorema apresentando um algoritmo com

custo polinomial que decide PATH.



Para encontrar um algoritmo polinomial que decida PATH (resolva o problema),

vamos empregar uma técnica de busca em grafos, denominada de busca em

largura, que marca (rotula) todos os nós de um grafo que são encontrados por

caminhos diretos de comprimento 1, 2, ..., m partindo de s.

Nota: Um algoritmo do tipo busca exaustiva não resolve este problema em tempo

polinomial. Se m é o número de nós do grafo, então um algoritmo de busca

exaustiva requer mm passos para decidir PATH e, portanto, possui custo

exponencial em relação ao número de nós.

Prova: Um algoritmo polinomial M que resolve PATH opera como abaixo:

M = Dada a entrada G,s,t, onde G é um grafo direcionado com nós s e t:

1. Rotule o nó s.

2. Repita os passos abaixo até que nenhum nó seja rotulado:

a. Leia todos os arcos de G. Se um arco (a,b) for encontrado indo de um nó

rotulado a um nó não rotulado b, rotule o nó b.



3. Se t estiver rotulado, aceite. Caso contrário, rejeite.

Análise:

Os Estágios 1 e 3 deste algoritmo são executados apenas uma vez. O Estágio 2.a é

executado no máximo m vezes, pois a cada vez que o grafo é lido, com exceção da

última, um nó é rotulado.

Portanto, a complexidade total do algoritmo é O(1+1+m) = O(m).

EPC 14: Execute, passo a passo ilustrando graficamente, o algoritmo acima para o

grafo da Figura 13.

Exemplo 12:

Dois números são relativamente primos se 1 é o maior inteiro que divide ambos os

números:

RELPRIME = {x,y | x e y são relativamente primos}.

Obs.: Note que, por exemplo, 10 e 21 são relativamente primos, embora nenhum

deles seja primo. Entretanto, 10 e 22 não são relativametne primos.



Teorema 4:

O problema RELPRIME P.

Idéia da Prova: Este problema pode ser resolvido usando um procedimento

antigo, denominado de algoritmo Euclidiano, que calcula o maior divisor comum

de dois números, ou seja, o maior inteiro que divide igualmente dois números x e

y.

Exemplo: mdc(18,24) = 6.

Prova: Seja E o algoritmo Euclidiano:

E = Dada uma entrada x,y, onde x e y são números naturais representados em

binário:

1. Repita até que y = 0.

a. x x mod y.

b. Troque x por y.

2. Output x.



O algoritmo R resolve o RELPRIME usando E como subrotina.

R = Dada a entrada x,y, onde x e y são números naturais representados em

binário:

1. Execute E para x,y.

2. Se o resultado for 1, aceite. Senão, rejeite.

Análise: Neste caso só é preciso analisar E.

Ver Sipser, p. 239.

Desafio:

Prove: Toda linguagem livre de contexto é um membro de P.



Exemplo 13:

Seja MST o problema de determinar a árvore geradora mínima (minimal

spanning tree - MST) de um grafo:

MST = {G,w | G é um grafo cuja árvore geradora mínima tem peso w}.

Uma árvore geradora (spanning tree) é um subconjunto dos arcos do grafo G tal

que todos os nós de G estão conectados por estes arcos e não há nenhum ciclo

formado.

Uma árvore geradora mínima ou árvore geradora de custo mínimo é aquela que

possui a menor soma total de pesos dentre as árvores geradoras.



t

1 2

3

4

15

10 12

18

20

Figura 14: Árvore geradora mínima.

Teorema 5:

O problema MST P.

Prova: É possível usar um algoritmo “guloso”, denominado de algoritmo de

Kruskal, para encontrar a MST:

1. Mantenha para cada nó o componente conectado no qual o nó aparece,

usando qualquer dos arcos selecionados da árvore. Inicialmente nenhum arco

está selecionado, então todo nó está em um componente conectado distinto.



2. Considere o arco de menor peso que ainda não foi considerado. Se este arco

conecta dois nós que estão em componentes conectados diferentes, então:

a. Selecione este arco para a árvore geradora; e

b. Una os dois componentes conectados envolvidos mudando o número do

componente de todos os nós em um dos dois componentes para que o

número do componente seja o mesmo.

Se o arco selecionado conecta dois nós do mesmo componente, este arco

não pertence à árvore geradora, pois criaria um ciclo.

3. Continue considerando arcos até que todos os arcos tenham sido

considerados, ou a quantidade de arcos selecionados para a árvore geradora

seja o número de nós menos um. Note que no último caso todos os nós

devem estar em um componente conectado.

Em um grafo com m nós e e arcos é possível implementar este algoritmo em um

tempo O(m + e log e).



Entretanto, é possível implementar este algoritmo de forma mais simples.

Considere uma tabela contendo o componente atual de cada nó. Selecione o

arco restante de menor peso em um tempo O(e) e encontre os componentes dos

dois nós conectados por este arco em um tempo O(m). Se eles estiverem em

componentes diferentes, una todos os nós com estes números em um tempo

O(m) lendo a tabela de nós. O custo computacional deste algoritmo é

O(e(e + m)). O custo deste algoritmo é polinomial em relação ao tamanho da

entrada, que pode ser tomado como sendo a soma de e mais m.

EPC 15: Execute, passo a passo ilustrando graficamente, o algoritmo acima para o

grafo da Figura 14.



13. A Classe NP

Como observado na seção anterior, é possível evitar a força bruta na resolução de

vários problemas e obter soluções em tempo polinomial que exploram as

características do problema sendo tratado.

Entretanto, há diversos problemas para os quais não são conhecidos algoritmos

polinomiais de solução.

o A razão para isso é desconhecida!

Sejam os seguintes conceitos:

o Verificação: para verificar se um determinado algoritmo possui tempo

polinomial basta executá-lo.

o Determinação: determinar significa encontrar um algoritmo com tempo

polinomial para um dado problema.

A verificação de uma determinada solução é em geral mais simples do que a

determinação de uma solução.



Definição 5:

Um verificador para uma linguagem A é um algoritmo V, onde

A = {w | V aceita w,c para alguma sentença c}

Um verificador utiliza informação adicional (c) para verificar se uma sentença w é

membro de A. Esta informação é denominada de certificado ou prova da

pertinência a A.

Definição 6:

NP é a classe de linguagens que possuem verificadores polinomiais.

A classe NP é importante pois ela contém diversos problemas de interesse prático.

O termo NP vem da expressão tempo polinomial não-determinístico, e é derivado

de uma caracterização alternativa que emprega máquinas de Turing polinomiais

não-determinísticas.



13.1. Exemplos de Problemas em NP

Exemplo 14:

Um caminho hamiltoniano em um grafo direcionado G é um caminho direcionado

que percorre cada nó uma única vez.

Consideremos o problema de testar se um dado grafo possui um caminho

hamiltoniano conectando dois nós especificados. Seja:

HAMPATH = {G,s,t | G é um grafo direcionado que possui um caminho

hamiltoniano de s para t}.

s

t

Figura 15: Caminho Hamiltoniano entre os nós s e t.



Assim como no caso do problema PATH, é possível obter um algoritmo de força

bruta com tempo exponencial para o problema HAMPATH, basta verificar se o

caminho potencial é hamiltoniano.

Não se sabe se o problema HAMPATH é resolvível em tempo polinomial.

Teorema 6:

O problema HAMPATH NP.

Idéia da Prova: Encontrar uma máquina de Turing não-determinística que decide

o problema HAMPATH em tempo polinomial não-determinístico.

Prova: Dada a entrada G,s,t, onde G é um grafo direcionado com nós s e t:

1. Escreva uma lista de m números, p1,..., pm, onde m é o número de nós do

grafo. Cada número da lista é não-deterministicamente selecionado entre 1

e m.

2. Procure repetições na lista. Se alguma for encontrada, rejeite.



3. Teste se s = p1 e t = pm. Se algum destes falhar, rejeite.

4. Para cada i entre 1 e m 1, verifique se (pi,pi+1) é um arco de G. Se algum

não for, rejeite. Caso contrário, aceite.

Análise:

No Estágio 1 a seleção não-determinística roda em tempo polinomial. Nos Estágios

2 e 3, cada parte corresponde simplesmente a uma checagem, portanto em conjunto

elas executam em tempo polinomial. O Estágio 4 também executa em tempo

polinomial.

Portanto, o algoritmo roda em tempo não-deterministicamente polinomial.

Exemplo 15:



Seja o problema dos números compostos: Um número natural é um número

composto se ele é o produto de dois inteiros maiores do que 1 (ou seja, um número

composto não é um número primo):

COMPOSTO = {x | x = pq, inteiros p, q > 1}.

Este problema é verificável em tempo polinomial.

o Embora não conheçamos um algoritmo em tempo polinomial para decidir este

problema, é possível verificar facilmente se um número é composto – tudo

que é necessário é um divisor para este número.

Assim como verificar a existência de um caminho Hamiltoniano é mais fácil do

que determinar sua existência, verificar se um número é composto (basta

encontrar um divisor para este número) é mais fácil do que encontrar um

algoritmo que decida este problema.

Exemplo 16:

Seja NHAMPATH o complemento do problema HAMPATH.



Mesmo se pudéssemos determinar de alguma forma que um grafo não possui um

caminho Hamiltoniano, não é conhecida forma alguma de verificar sua não

existência sem empregar o mesmo algoritmo de tempo exponencial para fazer a

determinação inicial.

Alguns problemas não são polinomialmente verificáveis!

Definição 7:

NTIME(t(n)) = {L | L é uma linguagem decidida por uma máquina de Turing não-

determinística de ordem O(t(n))}.

Corolário:

NP = k NTIME(nk)

A classe NP é insensível à escolha de modelos computacionais pois todos eles são

polinomialmente equivalentes.



Exemplo 17:

Um clique em um grafo não-direcionado é um subgrafo onde cada par de nós está

conectado por um arco. Um clique de tamanho k é um clique que contém k nós.

O problema do clique consiste em verificar se um grafo possui um clique de

determinado tamanho.

s

t

Figura 16: Clique de um grafo.

CLIQUE = {G,k | G é um grafo não-direcionado com um clique k}.



Teorema 7:

O problema CLIQUE NP.

Idéia da Prova: O clique é o certificado.

Prova: O seguinte V é um verificador para o CLIQUE.

V = Dada a entrada G,k,c:

1. Teste se c é um conjunto de k nós em G.

2. Teste se G contém todos os arcos conectando os nós em c.

3. Se ambos são satisfeitos, aceite; senão rejeite.

Prova Alternativa: A seguinte N é uma MTND que decide o CLIQUE.

N = Dada a entrada G,k, onde G é um grafo:

1. Selecione não-deterministicamente um subconjunto c de k nós de G.

2. Teste se G contém todos os arcos conectando os nós em c.

3. Caso afirmativo, aceite; senão, rejeite.



Exemplo 18:

Seja o problema SUBSET-SUM referente a aritmética inteira. Há uma coleção de

números x1,...,xk e um número alvo t. O objetivo é determinar se um conjunto de

números contém um subconjunto cuja soma é t:

SUBSET-SUM = {S,t | S = {x1,...,xk} e para algum {y1,...,yl} {x1,...,xk}, tem-se

i yi = t}.

P. ex. {2,3,4,5,9,11},8 SUBSET-SUM pois 5 + 3 = 8.

Teorema 8:

O problema SUBSET-SUM NP.

Idéia da Prova: O subconjunto é o certificado.

Prova: O seguinte V é um verificador para o SUBSET-SUM.

V = Dada a entrada S,t,c:

1. Teste se c é uma coleção de números que somam t.

2. Teste se S contém todos os números em c.



3. Se ambos são satisfeitos, aceite; senão rejeite.

Prova Alternativa: A seguinte N é uma MTND que decide o SUBSET-SUM.

N = Dada a entrada S,t:

4. Selecione não-deterministicamente um subconjunto c de números em S.

5. Teste se c é uma coleção de números que somam t.

6. Caso afirmativo, aceite; senão, rejeite.

EPC 16: No problema do caixeiro viajante (TSP – traveling salesman problem) um

vendedor precisa visitar n cidades exatamente uma vez utilizando a rota de custo

mínimo. Assuma que a partir de qualquer cidade é possível chegar nas demais. Uma

forma de resolver este problema é usando um algoritmo de força bruta (busca

exaustiva) que opera da seguinte maneira: encontre todas as rotas possíveis; calcule o

custo de cada uma das rotas; escolha a rota de menor custo. Qual a complexidade

deste algoritmo? É factível executá-lo para instâncias com um grande número de

cidades n?



14. A Distinção P NP

P é a classe de linguagens (problemas) cuja pertinência pode ser decidida

rapidamente.

NP é a classe de linguagens (problemas) cuja pertinência pode ser verificada

rapidamente.

O poder da verificabilidade polinomial parece ser muito superior ao da

decidibilidade polinomial, porém P pode ser igual a NP.

o Não somos capazes de provar a existência de uma linguagem em NP que não

está em P.

A questão se P = NP é um dos maiores problemas em aberto dentro da teoria da

computação e matemática.

Uma primeira observação é que, uma vez que uma DTM é uma NDTM que

sempre faz a mesma escolha de movimentos, P NP.

o Entretanto, parece que NP contém muitos problemas que não estão em P.



o A razão intuitiva é que uma NDTM que roda em tempo polinomial

consegue “adivinhar” um número exponencial de possíveis soluções para

um dado problema e checar cada uma delas em tempo polinomial em

paralelo.

Se estas classes forem iguais, qualquer problema polinomialmente verificável será

polinomialmente decidível.

o Ou seja, toda computação que puder ser realizada em tempo polinomial

por uma NDTM também poderá ser realizada em tempo polinomial por

uma DTM, talvez com um polinômio de maior grau.

Pesquisadores já tentaram sem sucesso obter algoritmos polinomiais para

problemas em NP e também demonstrar que as classes não são iguais, ambos

esforços sem sucesso.

Há um prêmio de US$1,000,000.00 para quem resolver este paradoxo:

http://www.claymath.org/millenium-problems/p-vs-np-problem

http://www.claymath.org/millenium-problems/p-vs-np-problem



Tópico 4: Problemas NP-Completos

15. Introdução

Um avanço na questão P versus NP veio no ano de 1970, quando S. Cook e L.

Levin descobriram alguns problemas em NP cuja complexidade estava

relacionada àquela de toda a classe.

Se algum algoritmo polinomial existir para qualquer um destes problemas, então

todos os problemas em NP seriam resolvidos em tempo polinomial.

Estes problemas são denominados de NP-completos.

o Sob o ponto de vista teórico, tentar mostrar que P não é igual a NP pode ser

feito através de um estudo com um problema NP completo. Se qualquer

problema em NP requer um tempo mais que polinomial, um problema NP-

completo também requer. Além disso, para mostrar que P = NP basta

encontrar um algoritmo polinomial para um problema NP-completo.



o Sob o ponto de vista prático, o fato de um problema ser NP-completo pode

resultar em economia de esforços na busca por um algoritmo de solução

polinomial, já que este não existe.

Problemas resolvíveis em tempo polinomial são ditos tratáveis e aqueles

resolvíveis em tempo exponencial (não polinomial) são ditos intratáveis.

Para estudar os problemas intratáveis usaremos o conceito de redução, porém de

forma um pouco distinta daquela apresentada durante o estudo de decidibilidade.

No contexto atual, não é mais suficiente que haja um algoritmo para transformar

instâncias de um problema em instâncias de outros problemas.

o O próprio algoritmo de redução deve ter custo polinomial. Caso contrário,

a redução não nos permite concluir que o problema a ser reduzido é

intratável, mesmo quando o problema redutor é intratável.



Outra distinção importante entre decidibilidade e tratabilidade é que enquanto a

decidibilidade depende apenas de matemática e de uma definição para a máquina

de Turing, a tratabilidade assume, em princípio, que P NP.

o Ou seja, assumimos que a classe de problemas que podem ser resolvidos

por NDTM em tempo polinomial inclui pelo menos alguns problemas que

não podem ser resolvidos por DTM em tempo polinomial.

o Há literalmente milhares de problemas que aparentemente pertencem a

esta classe, uma vez que eles podem ser resolvidos facilmente por uma

NDTM em tempo polinomial, mas nenhuma DTM com tempo polinomial

de solução é conhecida para eles.

Uma consequência importante da classe NP-completo é que ou todos os

problemas desta classe possuem soluções determinísticas em tempo polinomial,

ou nenhum deles possui.



Este tópico do curso está estruturado da seguinte forma: 1) mostrar como fazer a

redução polinomial de dois problemas; 2) mostrar que o problema de satisfazer

fórmulas Booleanas não pode ser resolvido em tempo polinomial (Teorema de

Cook-Levin); 3) mostrar como reduzir este problema a diversos outros.

16. Redução Polinomial

Uma redução é uma forma de converter um problema A em outro problema B tal

que a solução do segundo problema, B, possa ser usada para resolver o primeiro

problema, A.

o Exemplo cotidiano: O problema de encontrar um endereço na cidade de São

Paulo pode ser reduzido ao problema de obter um mapa da cidade.

A principal metodologia para provar que um dado problema B não pode ser

resolvido em tempo polinomial (B P) é a redução de um problema A (A P) a

B.



Sim Construa Decide

Não

Instância

de A Instância

de B

Suponha que o objetivo é provar a frase “se B P, então A P”.

o Como propomos que A P, também poderíamos propor que B P.

o Entretanto, a existência do algoritmo denominado “Construa” na figura acima

não é suficiente para provar esta afirmação.

Quando um problema A pode ser eficientemente reduzido a um problema B, uma

solução eficiente de B pode ser usada para resolver A eficientemente.



Definição 1:

Uma função f : * * é uma função computável em tempo polinomial se

alguma máquina de Turing M com tempo polinomial existe e pára com apenas

f(w) em sua fita, quando iniciada com w.

Definição 2:

Uma linguagem A é redutível em tempo polinomial à linguagem B, escrito A P B, se

uma função computável em tempo polinomial f : * * existe, onde para cada w,

w A f(w) B.

A função f é denominada de redução em tempo polinomial de A em B.

Se uma linguagem é redutível polinomialmente a uma outra linguagem que possui

uma solução polinomial, então é possível obter uma solução polinomial para a

primeira linguagem de acordo com o seguinte teorema:

Teorema 1:

Se A P B e B P, então A P.



Prova: Seja M um algoritmo polinomial que decide B e f uma redução polinomial

de A em B. É possível descrever um algoritmo polinomial N que decide A:

N = Dada a entrada w:

1. Calcule f(w).

2. Execute M para a entrada f(w) e leia a saída de M.

Se w A, então f(w) B pois f é uma redução de A em B.

16.1. Exemplo: Satisfiability Problem

O problema “satisfiability” (SAT) testa se uma expressão booleana é satisfeita.

Este problema pode ser demonstrado NP-completo reduzindo explicitamente a

linguagem de qualquer MTND polinomial ao problema satisfiability.

Exemplo 1:

Seja a seguinte expressão booleana:

E = x (x y)



Os valores verdade T(x) = 1 e T(y) = 0 resultam em um valor E(T) = 1 para a

expressão booleana, ou seja, a expressão é dita satisfeita.

Uma expressão booleana é dita satisfeita se existe pelo menos um valor verdade T

que satisfaz a expressão.

Outros valores verdade que satisfazem a expressão E acima são: T(x) = 1 e

T(y) = 1, pois mesmo o segundo termo sendo 0 (FALSO), o primeiro termo é 1

(VERDADEIRO).

Exemplo 2:

A expressão booleana abaixo não pode ser satisfeita:

E = x (x y) y.

Verifique!

Após introduzir o problema SAT, vamos considerar um caso particular deste,

denominado de 3SAT, para ilustrar a reducibilidade.



Seja um literal uma variável booleana ou sua negação (x ou x), e uma cláusula

um conjunto de literais ligados pelo conectivo .

o Diz-se que uma fórmula booleana está na forma normal conjuntiva (CNF),

denominada fórmula-CNF, se ela é composta por várias cláusulas

conectadas com .

o A fórmula é dita uma fórmula-3CNF se todas as cláusulas tiverem três

literais, como exemplificado abaixo:

(x1 x2 x3) (x1 x2 x3)

Exemplo 3:

Seja 3SAT = { | é uma 3CNF-fórmula que possa ser satisfeita}.

Em uma fórmula-CNF que pode ser satisfeita, cada cláusula deve conter pelo

menos um literal com valor especificado 1.

O teorema abaixo apresenta um redução polinomial do problema 3SAT ao

problema CLIQUE estudado no Tópico anterior.



Teorema 2:

3SAT é redutível polinomialmente ao problema CLIQUE.

Ideia da Prova: A redução polinomial do problema 3SAT para o problema

CLIQUE, reduz fórmulas a grafos. Nos grafos construídos, cliques de tamanho

específico correspondem a especificações que satisfazem a fórmula. As estruturas

do grafo são projetadas para imitar o comportamento das variáveis e cláusulas.

Prova: Seja uma fórmula com k cláusulas tal que

= (a1 b1 c1) (a2 b2 c2) ... (ak bk ck)

A redução de f gera a sentença G,k, onde G é um grafo não-direcionado como

definido a seguir:

o Os nós de G estão organizados em k grupos de três nós cada denominados

triplas, t1,...,tk.

o Cada tripla corresponde a uma das cláusulas em , e cada nó em uma tripla

corresponde a um literal na cláusula associada.



o Rotule cada nó em G com seu correspondente literal em .

o Os arcos de G conectam todos menos dois tipos de pares de nós em G:

1. nenhum arco está presente entre nós na mesma tripla; e

2. nenhum arco está presente entre nós complementares.

t x1

x1

x2

x1 x2 x2

x1

x2

x2

Figura 17: Grafo produzido pela redução de

= (x1 x1 x2) (x1 x2 x2) (x1 x2 x2)



é satisfeita se e somente se G possui um clique k.

o Suponha que tenha uma atribuição de valores verdade que a satisfaz.

o Nesta atribuição de valores verdade, pelo menos um literal é verdadeiro em

cada cláusula.

o Em cada tripla de G, selecionamos um nó correspondente a um literal com

valor verdadeiro (V) na atribuição de valores verdade.

o Os nós selecionados formam um clique-k.

Os Teoremas 1 e 2 afirmam que se o CLIQUE pode ser resolvido em tempo

polinomial, então o 3SAT também pode.

A primeira vista a conexão entre estes dois problemas parece pouco intuitiva, pois

superficialmente eles são bem diferentes.

Entretanto, a redução polinomial permite ligar suas complexidades.



17. Definição Formal de Problemas NP-Completos

Formalmente, diz-se que um problema (linguagem) L é NP-completo, se:

o L NP.

o Para toda linguagem L’ NP há uma redução polinomial de L’ para L.

Teorema 3:

Se B é NP-completo e B P, então P = NP.

Teorema 4:

Se B é NP-completo e B P C, para C NP, então C é NP-completo.

Exercício 1:

Prove os Teoremas 3 e 4.

17.1. O Teorema de Cook-Levin

O Teorema de Cook-Levin implica que o problema de satisfazer fórmulas

Booleanas não pode ser decidido em tempo polinomial.



Demonstrado que este problema não pode ser resolvido em tempo polinomial,

mostraremos que ele pode ser reduzido a vários outros problemas que, portanto,

também são intratáveis.

Dado um problema NP-completo, é possível obter outros problemas

NP-completos fazendo-se uma redução polinomial deste.

Entretanto, definir o primeiro problema NP-completo é mais difícil.

Façamos isso provando que o problema SAT é NP-completo.

Teorema 5:

SAT é NP-completo.

Ideia da Prova: É preciso mostrar duas coisas:

o Primeiro é necessário mostrar que o problema SAT NP, ou seja, é

preciso projetar uma MT polinomial não-determinística que encontre

uma atribuição de valores verdade para uma dada fórmula e aceite se

esta atribuição de valores verdade satisfizer .



o Em seguida é preciso mostrar que o SAT é NP-completo, ou seja, que

qualquer linguagem em NP é redutível em tempo polinomial ao

problema SAT.

Para mostrar que o SAT é NP-completo, faça uma redução em tempo

polinomial de cada linguagem A NP ao SAT. A redução para A toma

uma sentença w e produz uma fórmula booleana que simula a máquina

NP para A, dada a entrada w. Se a máquina aceita, possui uma

atribuição de valores verdade que resulta em uma fórmula verdadeira

correspondente a uma computação que resulta em um estado aceito. Se a

máquina não aceita, então nenhuma atribuição de valores verdade

satisfaz .

Nota: Uma fórmula booleana pode conter as operações booleanas AND, OR e

NOT, e estas operações formam a base dos circuitos usados em computadores

eletrônicos.



o Portanto, é possível projetar uma fórmula booleana para simular uma

máquina de Turing.

18. Problemas NP-Hard

Alguns problemas são tão difíceis de serem resolvidos que embora seja possível

provar a segunda condição da definição formal de problemas NP-completos (toda

linguagem em NP é redutível em tempo polinomial), não é possível provar a

primeira condição (L NP).

Neste caso, a linguagem (problema) L é dita NP-hard.

Problemas que aparentemente requerem tempo exponencial são ditos intratáveis.

Esta terminologia também é empregada como sinônimo de NP-hard, embora em

princípio há problemas que requerem tempo exponencial mesmo não sendo NP-

hard no sentido formal.

Provar que L é NP-hard é suficiente para mostrar que L possivelmente precisará de

tempo exponencial, ou pior.



Entretanto, se L NP, então sua dificuldade aparente não suporta o argumento de

que todos os problemas NP-completos são difíceis, ou seja, mesmo que P = NP, L

pode requerer tempo exponencial.

19. Exemplos de Problemas NP-Completos

Nesta seção vamos apresentar teoremas adicionais mostrando que várias

linguagens (problemas) são NP-completas.

O processo de descobrir novos problemas NP-completos possui dois efeitos

importantes:

o Ao descobrirmos que um problema é NP-completo, fica implícito que há

pouca chance de encontrarmos um algoritmo eficiente para solucioná-lo.

Neste caso, somos encorajados a usar heurísticas, soluções parciais,

aproximações, ou outras formas de evitar uma busca exaustiva.



o Cada vez que um novo problema P é adicionado à lista dos problemas NP-

completos, mais reforçamos a ideia de que todos os problemas NP-

completos requerem tempo exponencial de solução. O esforço investido na

tentativa de encontrar um algoritmo polinomial de solução de P também é,

mesmo que despercebidamente, investido na tentativa de verificar se

P = NP. O acúmulo de todas as tentativas fracassadas de se mostrar que

P = NP contribui para acreditarmos que estas classes são diferentes e,

portanto, todos os problemas NP-completos requerem tempo exponencial

de solução.

A ideia geral para se verificar se um dado problema é NP-completo é fazer uma

redução polinomial do problema 3SAT para a linguagem em questão, embora em

casos particulares seja possível reduzir de outras linguagens NP-completas mais

convenientes.

A grande maioria dos problemas NP-completos é do tipo combinatorial.



Durante o processo de redução polinomial, vamos procurar estruturas na

linguagem que possam simular as variáveis e cláusulas em fórmulas booleanas.

Estas estruturas são denominadas de gadgets.

Exemplo 4:

Na redução do 3SAT para o CLIQUE apresentada no Teorema 2, nós individuais

foram usados para simular variáveis e triplas de nós para simular cláusulas.

o Um nó pode ou não ser um membro de um clique, o que corresponde a

uma variável que pode ou não ser verdadeira em uma atribuição de

valores verdade válida.

o Cada cláusula deve conter um literal com valor verdadeiro e que

corresponda à forma com que cada tripla deve conter um nó no clique se

o tamanho do alvo tiver que ser atingido.

Corolário 1:

O CLIQUE é NP-completo.



19.1. Conjuntos Independentes (Independent Sets)

Seja G um grafo não-direcionado. Um subconjunto I de nós de G é um conjunto

independente (IS) se nenhum par de nós de I está conectado por um arco de G.

Um subconjunto independente é máximo se ele for o maior subconjunto

independente de nós deste grafo.

Exemplo 5:

t

1 2

3

4

15

10 12

18

20

Figura 18: O conjunto formado pelos nós 1 e 4, {1,4} é o

máximo conjunto independente de nós do grafo ilustrado.



Teorema 6:

O problema IS é NP-completo.

Ideia da Prova: 1) Provar que IS NP, 2) apresentar uma redução polinomial do

problema 3SAT ao IS e, em seguida, 3) mostrar que é satisfeita se e somente se

G possuir um conjunto independente de tamanho m.

Prova:

1) Para provar que IS NP, dado um grafo G e um limite k, determine k nós

aleatoriamente e verifique se eles são independentes.

2) Redução polinomial do 3SAT ao IS:



o Seja = (e1) (e2) ... (em) uma fórmula-3CNF.

o Construa um grafo G a partir de com 3m nós (i,j), 1 i m e j = 1, 2,

ou 3. O nó (i,j) representa o j-ésimo literal na cláusula ei.

Ver exemplo na Figura 3:

= (x1 x2 x3) (x1 x2 x4) (x2 x3 x5) (x3 x4 x5)



x1

(1,1) x1

(2,1)

x2

(3,1)

x3

(4,1)

x2

(1,2)

x2

(2,2)

x3

(3,2) x4

(4,2)

x3

(1,3)

x4

(2,3)

x5

(3,3) x5

(4,3)

Figura 19: Construção de um conjunto independente de nós a

partir de uma expressão booleana 3-CNF que pode ser satisfeita.

O “truque” na construção do grafo G é usar arcos para forçar qualquer conjunto

independente com m nós a representar uma maneira de satisfazer a fórmula .



As ideias principais da construção do grafo são:

o Garantir que apenas um nó correspondente a uma determinada cláusula

possa ser escolhido. Para isso, são colocados arcos entre todos os pares

de nós em uma coluna.

o Evitar que nós do conjunto independente sejam escolhidos se eles

representarem literais complementares. Para isso, são colocados arcos

entre os nós complementares.

O limite k para o grafo construído G é m.

O processo de construção do grafo requer um tempo proporcional ao quadrado do

comprimento de .

3) Agora resta mostrar que é satisfeita se e somente se G possui um conjunto

independente de tamanho m.



(Prova da parte se): Um conjunto independente não deve incluir dois nós da

mesma cláusula. Assim, se há um conjunto independente de tamanho m, este

conjunto deve incluir exatamente um nó de cada cláusula.

Além disso, um conjunto independente não deve incluir nós que correspondam a

uma variável e seu complemento, pois pares destes nós possuem um arco de

ligação.

Assim, o conjunto independente I de dimensão m resulta em uma atribuição de

valores verdade T para como a seguir.

o Se um nó correspondente a variável x está em I, faça T(x) = 1; se um nó

correspondente ao complemento de uma variável x está em I, faça



T(x) = 0. Se há um nó em I que corresponde a x ou x, escolha T(x)

arbitrariamente.

Neste caso T satisfaz , pois cada cláusula de possui o nó correspondente a um

de seus literais em I, e T é escolhido tal que o literal possui valor verdade TRUE.

Assim, quando um conjunto independente de tamanho m existe, então é

satisfeita.

(Prova do somente se): Agora suponha que seja satisfeita por alguma atribuição

de valores verdade T. Como T torna cada cláusula de TRUE, é possível

identificar um literal para cada cláusula que T torna TRUE. Caso haja mais de uma

possibilidade, escolha uma aleatoriamente.



Construa um conjunto de m nós I escolhendo aquele correspondente ao literal

selecionado a partir de cada cláusula.

I é um conjunto independente!

19.2. Cobertura de Vértices ou Nós (Vertex Cover)

Se G é um grafo não-direcionado, uma cobertura de vértices (nós) de G é um sub-

conjunto de nós onde cada arco de G toca pelo menos um destes nós.

o O problema de cobertura de vértices pergunta o tamanho k da menor

cobertura de vértices, ou seja, a cobertura mínima de nós.

Seja:

VERTEX-COVER = {G,k | G é um grafo não-direcionado que possui uma

cobertura de vértices com k-vértices}



Teorema 7:

O problema VERTEX-COVER é NP-completo.

Ideia da Prova: Apresentar uma redução polinomial do problema 3SAT ao

VERTEX-COVER e, portanto, mostrar que é satisfeita se e somente se G possui

uma cobertura de vértices com k nós.

Prova: A redução mapeia uma fórmula booleana a um grafo G e um valor k.

Cada arco em G deve tocar pelo menos um nó na cobertura do vértice, de forma

que um gadget natural para uma variável seja um único arco.



Setar esta variável em TRUE corresponde a selecionar o nó a esquerda para a

cobertura do vértice, e um valor FALSO corresponde a selecionar o nó a direita.

Os gadgets para as cláusulas são um pouco mais complexos. Cada gadget das

cláusulas é uma tripla de nós rotulados com os três literais da cláusula. Estes três

nós estão conectados entre si e aos nós dos gadgets das variáveis que possuem

rótulos idênticos.

Assim, o número total de nós de G é 2m + 3l, onde possui m variáveis e l

cláusulas. Seja k = m + 2l.



x2

x1

x1

x1

x2 x2

x1

x2 x2

x1 x1 x2 x2

Figura 20: Grafo produzido pela redução de

= (x1 x1 x2) (x1 x2 x2) (x1 x2 x2). k = 8.

Para provar que esta redução funciona, é preciso provar que é satisfeita se e

somente se G possui uma cobertura de vértices com k nós.

Começamos com uma atribuição de valores verdade que satisfaz . Vamos colocar

os nós dos gadgets das variáveis que correspondem aos literais TRUE da

atribuição de valores verdade na cobertura de vértices.



Em seguida, selecionamos um literal TRUE em cada cláusula e colocamos os dois

nós remanescentes do gadget de cada cláusula na cobertura de vértices. Agora

temos um total de k nós. Eles cobrem todos os arcos pois os arcos dos gadgets de

todas as variáveis estão cobertos, todos os três arcos do gadget de cada cláusula

estão cobertos, e todos os arcos entre os gadgets de variáveis e cláusulas estão

cobertos. Portanto, G possui uma cobertura de vértices com k nós.

Dado que G possui uma cobertura de vértices com k nós, mostramos que é

satisfeita construindo a atribuição de valores verdade. Tomando os nós dos

gadgets das variáveis na cobertura de vértices como TRUE, tem-se uma atribuição

de valores verdade que satisfaz , pois cada um dos três arcos conectando os

gadgets das variáveis com o gadget de cada cláusula está coberto e apenas dois

nós do gadget da cláusula estão na cobertura de vértices. Portanto, um dos arcos

deve ser coberto por um nó de um gadget de variável e assim esta atribuição de

valores verdade satisfaz a cláusula correspondente.



Outra forma de provar o Teorema 7 (Vertex Cover NP-completo) é através do

uso dos conjuntos independentes.

O problema de cobertura de vértices está intimamente relacionado ao problema de

conjuntos independentes.

o O complemento de um conjunto independente é uma cobertura de nós e

vice-versa.

Outra Prova para o Teorema 7: Apresentar uma redução polinomial do problema

IS para o VERTEX-COVER e, portanto, mostrar que G possui um conjunto

independente de tamanho k, se e somente se G possui uma cobertura de nós de

tamanho n k.

Seja um grafo G com limite inferior k um exemplo de problema do conjunto

independente. Seja G com n nós, construa um G com limite superior n k como um

exemplo do problema de cobertura de nós.



o G possui um conjunto independente de tamanho k se e somente se G possui

uma cobertura de nós de dimensão n k.

(Prova do se) Seja N o conjunto de nós de G e seja C a cobertura de nós de tamanho

n k. N C é um conjunto independente. (Verifique por contradição.)

(Prova do somente se) Assuma que I seja um conjunto independente de k nós.

N I é uma cobertura de nós com n k nós. (Verifique por contradição.)



Tópico 5: Computação de DNA

1. Introdução

A computação de DNA é uma das subáreas de uma linha de pesquisa mais ampla

denominada de computação molecular.

Em linhas gerais, a computação molecular emprega (bio)moléculas e operações

para a manipulação destas (bio)moléculas para resolver problemas e realizar

computação.

Questões importantes a serem verificadas:

o Qualquer algoritmo pode ser “simulado” via computação de DNA?

o Quais as dificuldades em se projetar um computador de DNA?



Diversos modelos de computação de DNA vêm sendo propostos para responder

estas e outras questões. Estes modelos podem ser divididos em dois grandes

grupos:

o Modelos baseados em filtragem

o Modelos formais

De maneira simplificada a computação de DNA emprega moléculas de DNA como

estrutura de dados e manipula estas moléculas de forma a realizar computação.

1.1. Computação de DNA x Computadores Tradicionais

A computação de DNA utiliza DNA como estrutura de dados. Alfabeto quaternário

{A,C,T,G} ao invés de binário {0,1}.

Computadores de DNA operam de forma massivamente paralela.

A computação de DNA opera em nível molecular, um limite que talvez jamais será

atingido pela indústria de semicondutores.



Os computadores de DNA demandam muito pouca energia e são altamente

econômicos na armazenagem de informação.

Os computadores de DNA são eficientes na resolução de problemas NP-completos.

2. Conceitos Básicos de Biologia Molecular

2.1. A Molécula de DNA

Toda a informação genética em organismos celulares está armezanada no DNA,

que consiste em cadeias de polímeros, usualmente conhecidas como cadeias de

DNA.



gene gene

gene

Dupla hélice de DNA

Figura 21: A molécula de DNA encontra-se no núcleo das células.

As cadeias de DNA são formadas por quatro unidades de ácidos nucléicos,

chamados de deoxyribonucleotídeos ou simplesmente nucleotídeos.

Existem quatro nucleotídeos no DNA, e cada nucleotídeo é composto por três

partes: uma molécula base, um açúcar e um grupo fosfato.

As quatro bases são: adenina (A), citosina (C), guanina (G), e timina (T).



Como os nucleotídeos diferem apenas pelas bases, eles são geralmente

denominados de bases.

Números de 1 a 5 são usados para denotar os cinco átomos de carbono do açúcar

do nucleotídeo. O grupo de fosfato se liga ao átomo de carbono 5, e a base se liga

ao átomo de carbono 1.

Cada cadeia possui, por convenção química, um terminal 5 e um terminal 3.

Portanto, cada cadeia possui uma orientação.



Fosfato Açúcar Base

5

4

3

2

1

Base

Fosfato P O CH2

O C C

C C H H

OH H

5

CH3

O

HN

CH C

C

N

C

O

4 3 2

1

Figura 22: Estrutura química do nucleotídeo e uma de suas representações.

Os nucleotídeos podem se ligar de duas formas distintas:

o O grupo de fosfato 5 de um nucleotídeo se junta ao grupo de hydroxil 3 de

outro nucleotídeo formando uma ligação covalente;

o A base de um nucleotídeo interage com a base de outro para formar uma ponte

de hidrogênio, que é uma ligação mais fraca do que uma ligação covalente.



Uma característica importante da ligação de nucleotídeos (ligação covalente) é que

qualquer nucleotídeo pode se ligar para formar uma seqüência.

Por outro lado, as ligações entre as bases só ocorrem pela atração entre pares

específicos de bases:

o A se liga com T

o C se liga com G

Estas ligações são denominadas de complementaridade de Watson-Crick.

A

T

C

G

A

T

C

G

T

A

G

C

T

A

G

C

C

T

G

A

G

A

C

T

5

3

5

3

Figura 23: Molécula de DNA ilustrando a complementaridade de Watson-Crick.



Algumas representações alternativas:

A

T

C

G

A

T

C

G

T

A

G

C

T

A

G

C

C

T

G

A

G

A

C

T

5

3

5

3

5 T C G A T T G A A C C 3

3 A G C T A A C T T G G 5

5 T C G A T T G A 3

3 A A C T T G G 5 (Sticky ends)



2.2. Manipulando o DNA

Todas as técnicas de computação de DNA envolvem a aplicação de um conjunto

específico de operações biológicas a um conjunto de moléculas.

o Desnaturação: separa cadeias de DNA (separa as bases)

o Annealing: junta cadeias de DNA (une pelas bases)

o Extensão de polimerase: completa cadeias incompletas

o Degradação por nuclease: encurta cadeias de DNA

o Endonucleases: corta moléculas de DNA (separa pelas ligações covalentes)

o Ligação: une moléculas de DNA (une pelas ligações covalentes)

o Modificação de nucleotídeos: insere ou deleta pequenas seqüências

o Amplificação (PCR): multiplica moléculas de DNA

o Eletroforese de gel: mede o comprimento de moléculas de DNA

o Filtragem: separa ou extrai moléculas específicas

o Síntese: cria moléculas de DNA

o Seqüenciamento: lê a seqüência de uma molécula de DNA



C

T

G

A

G

A

C

T

5

3

5

3

C

T

G

A

G

A

C

T

5

3

5

3

Annealing

Denaturing (melting)

5 T C G A T T G A A 3 (single strand)

3 A A C T T C 5 (single strand)

(Annealing)

5 T C G A T T G A A 3

3 A A C T T C 5

Figura 24: Desnaturação e annealing.



5 T C G A T T 3 (primer)

3 A G C T A A C T T 5 (template)

5 T C G A T T G 3

3 A G C T A A C T T 5

5 T C G A T T G A 3






5 T C G A T T G A 3

3 G C T A A C T T 5

5 T C G A T T G 3

3 C T A A C T T 5

5 T C G A T T 3

3 T A A C T T 5

(a) (b)

Figura 25: (a) Extensão de polimerase. (b) Degradação por nuclease.

5 T G A A T T C C G 3

3 A C T T A A G G C 5

5 T G 3 5 A A T T C C G 3

3 A C T T A A 5 3 G G C 5

5 T G C C C G G G A 3

3 A C G G G C C C T 5

5 T G C C C 3 5 G G G A 3

3 A C G G G 5 3 C C C T 5

Figura 26: Corte por endonuclease.



OH P



P OH

OH P



P OH



Figura 27: Ligação.



a b c

a b c

Denaturation

Denaturation

Template

Primers a c

a c

a

c

c

a

c

a

a

c

Polymerase extension

Figura 28: PCR (Polymerase Chain Reaction).



Figura 29: Fotografia de uma eletroforese de gel de uma molécula de proteína.



3. Modelos Baseados em Filtragem

Em todos os modelos baseados em filtragem, um grande conjunto de sentenças é

gerado e diversos processos de filtragem são aplicados de forma a filtrar sentenças

que não podem ser solução do problema.

3.1. O Experimento de Adleman

O primeiro experimento bem sucedido na utilização de moléculas de DNA e

técnicas de manipulação de DNA na solução de problemas foi apresentado por

Adleman em 1994.

Neste trabalho, Adleman resolveu uma pequena instância de um problema de

caminho Hamiltoniano (HPP).

o Um grafo direcionado G com os nós de entrada e saída definidos, vin e vout,

possui um caminho Hamiltoniano se e somente se existe uma seqüência de

ramos direcionados e1, e2,…,ez (caminho) que inicia em vin e termina em vout.



2

0

6

1

3

4 5

Figura 30: Grafo usado no experimento de Adleman.

O HPP pode ser resolvido de forma exaustiva e, embora haja algoritmos capazes

de resolver instâncias específicas de forma eficiente, todos os algoritmos de

solução possuem complexidade exponencial no pior caso.

o Portanto, na prática o HPP é um problema intratável usando as técnicas

tradicionais de computação.



o Com a proposta de Adleman usando computação de DNA, o número de

operações em laboratório a serem empregadas na solução do HPP é linear em

função do tamanho do grafo (número de vértices), embora o problema continue

sendo NP-completo.

Algoritmo para resolver o problema:

Passo 1: gere caminhos aleatórios pelo grafo.

Passo 2: mantenha apenas aqueles que iniciam em vin e terminam em vout.

Passo 3: se o grafo possui n vértices, mantenha somente aqueles caminhos de

comprimento n.

Passo 4: mantenha apenas aqueles que passam por cada nó uma única vez.

Passo 5: se um caminho permanecer, aceite; caso contrário rejeite.

Antes de aplicar o algoritmo determinístico acima para resolver este problema, é

necessário “codificar” os possíveis caminhos utilizando moléculas de DNA.



Adleman codificou cada nó do grafo utilizando uma seqüência de nucleotídeos

(single strand) de comprimento 20.

A codificação foi escolhida aleatoriamente e o comprimento de 20 bases foi

adotado para garantir uma codificação diferente para cada nó.

Uma grande quantidade de nucleotídeos foi gerada via PCR e colocada em um

tubo de ensaio.

Os ramos foram codificados da seguinte forma:



v1 = 5 T G A A T T C C G A | C G T C C A G T G A 3

v2 = 5 A T G A A C T A T G | G C A C G C T A T C 3

v3 = 5 C A T A G T C C G A | T T A G C A G T A G 3

e12 = 3 G C A G G T C A C T | T A C T T G A T A C 5

e21 = 3 C G T G C G A T A G | A C T T A A G G C T 5

e13 = 3 G C A G G T C A C T | G T A T C A G G C T 5

(a)

T G A A T T C C G A C G T C C A G T G A A T G A A C T A T G G C A C G C T A T C G C A G G T C A C T T A C T T G A T A C

(b)

v1 v2

e12

Figura 31: Método de codificação usado por Adleman para resolver o problema do caminho

Hamiltoniano.



Método de Solução

Passo 1: gere caminhos aleatórios pelo grafo.

Para ligar os vértices de modo a formar caminhos, oligonucleotídeos Ōi

complementares aqueles representando os nós (Oi) são gerados.

Para unir as ‘single strands’ e gerar os caminhos aleatórios pelo grafo foi feito o

annealing e foi utilizada uma reação de ligação.

Passo 2: mantenha apenas aqueles caminhos que iniciam em vin e terminam em vout.

Em seguida, uma PCR empregando Ō0 e Ō6 como primers é utilizada para

amplificar o resultado do passo anterior.

Dessa forma, apenas as moléculas que iniciam no nó 0 e terminam no nó 6 foram

amplificadas.

Um processo de filtragem separa estas moléculas das demais.



Passo 3: se o grafo possui n vértices, mantenha somente aqueles caminhos de

comprimento n.

A eletroforese de gel é utilizada para separar as moléculas (double stranded) de

acordo com seus comprimentos.

Apenas as cadeias com comprimento 140 pares base (7 vértices) foram mantidas.

Ao final deste passo existem diversas moléculas que iniciam no nó 0, terminam no

nó 6 e passam por 7 nós.

Passo 4: mantenha apenas aqueles que passam por cada nó uma única vez.

Com um passo para cada vértice, foi possível verificar se as moléculas restantes

possuíam estes vértices. (filtragem)

Passo 5: se um caminho permanecer, aceite; caso contrário rejeite.



Discussão

Adleman demorou 7 dias para completar seu experimento.

o Entretanto, a quantidade de nucleotídeos necessária para resolver o problema

cresce linearmente com o número de nós do problema.

Portanto, um problema NP-completo que requer mais tempo de processamento

quanto maior o tamanho do problema, pode ser resolvido em tempo linear devido

ao paralelismo da computação de DNA.

Uma das dificuldades do procedimento adotado por Adleman está relacionada a

quantidade de single strands que devem ser geradas para codificar os diversos

caminhos possíveis no grafo.

Como o HPP é um problema NP-completo e ele foi resolvido por uma técnica de

computação de DNA, em teoria é possível utilizar esta mesma estratégia para

resolver qualquer problema da classe NP.



Entretanto, isso não significa que qualquer instância de um problema NP possa ser

resolvida de forma factível por computação de DNA.

Adleman resolveu o problema HPP usando a força bruta: ele projetou um sistema

capaz de gerar e avaliar todas as possíveis soluções para uma dada instância do

HPP.

A característica marcante do experimento de Adleman foi o paralelismo massivo

das moléculas de DNA.

Em 1994, quando Adleman executou seu experimento, um computador do tipo

desktop comum era capaz de executar 106 operações por segundo e o

supercomputador mais rápido conhecido podia executar aproximadamente 1012

operações por segundo.

o O computador de DNA de Adleman era capaz de executar 1014 operações por

segundo, assumindo que cada ligação corresponde a uma operação. Escalonando

o passo de ligação poderia elevar este número para 1020.



o Além disso, a quantidade de energia consumida era muito baixa, da ordem de

2 1019 operações por joule, um valor próximo do limite proposto pela segunda

lei da termodinâmica (34 1019).

o Os supercomputadores modernos operam na casa de 109 operações por joule.

o Por último, em um computador de DNA um bit de informação pode ser

armazenado em um nanômetro cúbico de DNA, que é aproximadamente 1012

vezes mais eficiente que os dispositivos de armazenagem conhecidos na época.

o Em resumo, um computador de DNA podia ser, em 1994, 1.200.000 vezes mais

rápido do que o supercomputador mais rápido conhecido, além de permitir um

armazenamento de informação 1012 vezes mais eficiente e consumir 1010 vezes

menos energia que os computadores existentes.

3.2. A Solução de Lipton para o Problema SAT

Lipton mostrou como empregar procedimentos de DNA para resolver o problema

denominado de satisfiability problem for propositional formulas (SAT).



SAT é um problema de busca NP-completo que pode ser definido como a seguir.

Dado um conjunto finito de variáveis lógicas E = {e1, e2,…, en}, defina um literal

como sendo uma variável, ei, ou seu complemento ēi. Se ei é verdadeira, então ēi é

falsa, e vice-versa.

Seja uma cláusula Cj um conjunto de literais {e1j, e2

j,…, elj}.

Uma instância I do problema SAT consiste em um conjunto de cláusulas, mais

especificamente, uma fórmula Booleana da forma C1 C2 … Cm, onde cada

cláusula é uma proposição que pode ser construída a partir de variáveis

proposicionais ei, i = 1,…, e conectivos lógicos AND (), OR (), e NOT ().

O problema SAT corresponde portanto a especificar um valor Booleano para cada

variável ei E, i = 1,…,n, tal que toda a fórmula seja verdadeira.

Um aspecto chave explorado por Lipton foi o fato de podermos representar o

problema SAT como um problema de busca em grafos.



e10 e2

0 e30 en–1

0 en0

v0 v1 v2 . . . vn–1 vn

e11 e2

1 e31 en–1

1 en1

Figura 32: Representação em grafo do problema SAT.

De acordo com a figura acima, um caminho genérico pode ser representado por

uma seqüência v0e1i1v1e2

i2… vn–1eninvn, onde a variável ej pode assumir o valor

verdade ij, j = 1,…n.

Neste grafo, todos os caminhos que iniciam em v0 e terminam em vn correspondem

a uma sentença binária.

o Por exemplo, o caminho v0e11v1e2

0v2e30…vn–1en

1vn codifica a sentença binária

100…1.



Assim como a solução de Adleman, Lipton também propôs um método composto

por duas fases principais:

o Gerar todas as soluções possíveis (caminhos no grafo)

o Filtrar aquela(s) que satisfaz(em) o problema

Lipton propôs codificar os grafos em um tubo de ensaio como feito por Adleman e

utilizou o mesmo esquema de codificação.

Por outro lado, a forma de solução proposta por Lipton foi diferente em essência.

Ele propôs trabalhar com operações em tubos de ensaio.

Para exemplificar, foi verificada a seguinte expressão: F = (e1 e2) (ē1 ē2).

e10 e2

0

v0 v1 v2

e11 e2

1



Lipton construiu uma série de tubos de ensaio, onde o primeiro tubo t0

supostamente contém todas as possíveis soluções do problema.

Ele propôs, dentre outras, uma operação de extração E(t,i,a) que extrai todas as

seqüências no tubo t cujo i-ésimo bit é a, a {0,1}.

Em seguida, ele propôs o seguinte algoritmo para resolver o problema:

Passo 1: Seja t1 o tubo correspondente a E(t0,1,1). O tubo contendo o restante é t1, e

t2 é E(t1,2,1). Junte o conteúdo de t1 e t2 produzindo o tubo t3.

Passo 2: Seja t4 o tubo correspondente a E(t3,1,0). O tubo com o conteúdo restante é

t4, e t5 é E(t4,2,0). Junte o conteúdo de t4 e t5 produzindo o tubo t6.

Passo 3: Verifique se há alguma molécula de DNA no último tubo. Caso afirmativo,

aceite; caso contrário, rejeite.



Tubo de ensaio

Strings presentes

t0 00, 01, 10, 11

t1 10, 11

t1 00, 01

t2 01

t3 01, 10, 11

t4 01

t4 10, 11

t5 10

Caso Genérico

Qualquer problema SAT com n variáveis e m cláusulas pode ser resolvido com, no

máximo, O(m) operações de extração e uma operação de detecção.

Sejam C1, C2,…, Cm as m cláusulas de uma fórmula proposicional.

Construa m tubos, t0, t1,…, tm, de forma que tk seja o conjunto de números com n-

bits tal que C1(e) = C2(e) = … = Ck(e) = 1, onde Ci(e) corresponde ao valor verdade

da cláusula Ci sobre o conjunto de variáveis e.



Para t0 use todas as combinações possíveis de cláusulas.

Dado tk, construa tk+1 da seguinte forma. Assuma que Ck+1 está na forma disjuntiva:

o1 ... ol, onde oi é um literal e ōi é o complemento de um literal.

Para cada literal opere da seguinte forma:

o Se oi = ej, então gere E(tk,j,1).

o Senão, se oi = ēj, gere E(tk,j,0).

Cada operação de extração é efetuada e o restante é colocado em um outro tubo.

Junte todos os tubos e faça uma detecção. Se sobrar algo, então a fórmula é

satisfeita.

Discussão

Em essência, nenhum método é melhor do que a busca exaustiva na solução do

SAT.



Neste sentido, o método utilizado pela computação de DNA não é melhor do que

os de busca exaustiva, porém ele faz uso do paralelismo massivo das moléculas de

DNA e suas técnicas de manipulação.

Um dos principais resultados da solução proposta por Lipton foi a verificação de

que seu procedimento permite resolver qualquer problema SAT de n variáveis e m

cláusulas com, no máximo, m passos de extração e uma detecção.

3.3. Linguagem de Programação de Tubos de Ensaio

Os aspectos práticos das propostas de Lipton e Adleman dependem das tecnologias

de manipulação de DNA disponíveis.

Até mesmo os algoritmos utilizados para resolver os problemas poderiam ser

mudados.

O que é importante neste caso é provar que a computação é factível.



Meios puramente bioquímicos foram empregados para resolver problemas NP-

completos em um tempo linear em relação a quantidade de operações de

laboratório.

Estas operações, em uma formulação abstrata, constituem uma outra grande

contribuição da proposta de Adleman e sua filosofia, resultando em uma espécie de

linguagem de programação de tubos de ensaio baseada em moléculas de DNA

colocadas em tubos de ensaio e mecanismos para manipulação destas moléculas.

O Modelo Irrestrito

Um tubo de ensaio é um conjunto de moléculas de DNA, ou seja, um multi-

conjunto de sentenças finitas construídas a partir de um alfabeto {A,C,G,T}.

Dado um tubo, é possível realizar quatro operações básicas:



1. Separate (extract) dado um tubo t e uma palavra w (cadeia de símbolos

w pertencentes ao alfabeto {A,C,G,T}), produza dois tubos +(t,w) e (t,w),

onde +(t,w) consiste de todas as cadeias de DNA em t que contêm w como

sub-seqüência, e (t,w) consiste de todas as cadeias de DNA em t que não

contêm w como sub-seqüência.

2. Merge: dado um conjunto de tubos t1, t2, …, tm, produza um tubo com o

conteúdo de todos os outros tubos: (N1,N2,…,Nm) = N1 N2 … Nm.

3. Detect: dado um tubo t, aceite se t contém pelo menos uma molécula de

DNA, e rejeite caso contrário.

4. Amplify: dado um tubo t, produza duas cópias t1 e t2: t = t1 = t2.

Estas quatro operações podem ser empregadas para escrever programas que

recebem como entrada um tubo e produzem como saída uma resposta aceite

(YES), rejeite (NO) ou um conjunto de tubos.



Além destas operações, o experimento de Adleman utiliza a complementaridade de

Watson-Crick e as seguintes modificações da operação separate:

1. Length-separate: dado um tubo t e um inteiro n, produza o tubo (t, n)

que consiste de todas as cadeias em t de comprimento menor ou igual a n.

2. Position-separate: dado um tubo t e uma palavra w, produza um tubo

B(t,w) que possui todas as cadeias em t que iniciam com a palavra w; ou

produza o tubo E(t,w) que contém todas as cadeias em t que terminam com a

palavra w.

Exemplos de aplicação:



procedure [out] = extract(t,A,T,G)

t (t,T)

t (t,G)

t (t,A)

out detect(t)

end procedure

o O que o programa acima faz?



procedure [out] = HPP(t,vin,vout)

t B(t,vin)

t E(t,vout)

t (t, 140) for i=1 to 5 do

t +(t,si)

end for

out detect(t)

end procedure

Na proposta de Lipton para o problema SAT, uma operação extract E(t,i,a) que

extrai todas as seqüências de um tubo t cujo i-ésimo bit é igual a a, foi definida:

E(t,i,a) = +(t,eia),

E(t,i,a) = (t,eia),

onde E(t,i,a) extrai todas as seqüências no tubo t cujo i-ésimo bit é complementar

a a.



procedure [out] = SAT(t)

t1 +(t,e11)

t1’ (t,e11)

t2 +(t1’,e21)

t3 merge(t1,t2)

t4 +(t3,e10)

t4’ (t3,e10)

t5 +(t4’,e20)

t6 merge(t4,t5)

out detect(t6)

end procedure

EPC 17: Escreva um programa em LPTE que extraia todas as sentenças de um tubo

t que tenham apenas a palavra GATA.

EPC 18: Escreva um programa em LPTE que extraia todas as sentenças de um tubo

t que contenham apenas vogais.

EPC 19: Codifique todas as letras do alfabeto português utilizando o alfabeto

quaternário do DNA e faça um programa em LPTE que extraia todas as sentenças de

um tubo t que tenham seu nome.



A Linguagem Pascal-DNA

Com o objetivo de fornecer um modelo em alto nível para a computação

molecular, foi introduzida uma outra linguagem de programação combinando

elementos de Pascal com operadores de manipulação de DNA.

Nesta linguagem, denominada de DNA Pascal, tubos de ensaio com moléculas de

DNA foram mapeados em variáveis contendo palavras do alfabeto {0,1}.

o Initialization: preenche um conjunto de variáveis t com {0,1}n,

t := In(n).

o Empty word: t :={}.

o Union: união de dois conjuntos de variáveis t1 e t2, t := t1 t2.

o Extraction: filtra todas as palavras de um conjunto de variáveis t1 que

possuem um padrão especial. Os autores propuseram dois tipos de

procedimentos de extração: 1) uma extração de bits, e 2) uma extração de sub-

palavras.



o Bit extraction: procura um bit especial b em uma posição particular k,

t := Bx(t1,b,k).

o Sub word extraction: a extração procura uma palavra sub-palavra

especial w em qualquer lugar da palavra, t := Sx(t1,w).

o Concatenation: a concatenação de dois conjuntos de variáveis t1 e t2 é

t := t1.t2.

o Right cut: t := t1/, onde t1/ = {z/ | z t1} e za/ = z a {0,1} e / = .

o Left cut: t := /t1, onde /t1 = {/z | z t1} e /za = z a {0,1} e / = .

o Right append: t := t1.a, onde t1.a = {z.a | z t1}.

o Left append: t := a.t1, onde a.t1 = {a.z | z t1}.

Alguns testes condicionais também foram propostos:

o Subset test: t1 t2.

o Detect test: t = 0.

o Membership test: x t.



4. Um Breve Resumo dos Modelos Formais

Virtualmente cada pesquisador em computação de DNA possui sua própria forma

de utilizar DNA para computar.

Isso indica que esta linha de pesquisa ainda está explorando as diversas

possibilidades de implementar um computador de DNA.

Entretanto, diversos modelos formais, alguns introduzidos antes do experimento de

Adleman, têm sido propostos com o objetivo de fornecer um estudo teórico sobre a

computação de DNA. Dentre eles é possível citar os:

o sticker systems: Roweis et al. (1996) introduziram um modelo de computação de

DNA chamado de sticker model. Assim como os modelos de filtragem, este

modelo emprega cadeias de DNA como o substrato físico para armazenar e

processar informação. O modelo de stickers possui uma memória de acesso

aleatório que não requer a extensão de cadeias de DNA, não utiliza enzimas, e

(em teoria) utiliza material reaproveitável.



o splicing systems ou sistemas H: De forma simples, cortar (splice) duas sentenças

corresponde a partí-las em pontos específicos e concatenar os fragmentos

obtidos de uma forma similar a feita com cromossomos durante um crossover.

Este modelo é baseado em linguagens formais e a operação de splicing.

o insertion/deletion systems: As operações de inserção e deleção são fundamentais

em linguagens formais. Dado um par de palavras (x,y), denominado contexto,

um operador de inserção permite inserir uma palavra v entre x e y.

o modelo PAM (parallel associative memory model): Este modelo basicamente

descreve um operador de ligação paralela e associativa. Ele também utiliza

operadores comuns em computação de DNA como união, extração e deleção.



5. Computadores Universais de DNA

A verificação da capacidade de computação universal de um computador de DNA

tem sido feita de várias formas utilizando diferentes computadores universais,

como máquinas de Turing, autômatos celulares, circuitos Booleanos, e gramáticas

de Chomsky.

Como uma máquina de Turing universal pode, em princípio, computar qualquer

função computável, projetar uma máquina de Turing universal utilizando DNA

constitui um passo importante na direção de provar a universalidade da

computação de DNA.

Neste caso, é preciso especificar um computador molecular capaz de manter um

estado e uma memória, e capaz de executar uma quantidade indefinida de

transições de estados.



D. Beaver projetou uma máquina de Turing consistindo de uma única molécula de

DNA onde os mecanismos químicos para a transição de estados permitem uma

computação paralela, sincronizada e heterogênea.

A cada passo do modelo proposto, uma molécula de DNA codifica uma

configuração da máquina de Turing: o conteúdo da fita, seu estado atual e a

posição do cabeçote.

Cada transição de estado requer um esforço O(1) em termos de passos de

laboratório a serem executados.

Como uma única cadeia de DNA é utilizada para codificar a configuração de uma

máquina de Turing, Beaver primeiramente mostrou como implementar uma

substituição dependente de contexto em uma molécula de DNA.

o Isso foi feito porque simular uma computação (passo) de uma MT

corresponde a substituir uma parte da configuração de uma MT.



A ideia é substituir a porção de DNA que irá sofrer a transição de estado. (ver

figura)

Configuração: C = (x1…xk1qxkxk+1…xm)

Codificação: Ce = e(x1,1)…e(xk1,k1)e(q,k)e(xk,k)…e(xm,m), onde e(xk,k) indica

que o símbolo xk está na k-ésima posição da fita e e(q,k) indica o estado atual

da máquina.

Note que neste esquema o conteúdo da máquina de Turing, juntamente com o

estado q atual da máquina são codificados um a um e concatenados para formar

uma cadeia de DNA que codifica a configuração da máquina.

Para que ocorra uma transição, a molécula é isolada em um tubo de ensaio de

acordo com o estado q, posição do cabeçote k, símbolo xk sendo lido atualmente e

os símbolos xk1 a esquerda e xk+1 a direita do cabeçote.

Os valores de q e xk determinam a transição de estados a ser realizada:

o (q,xk) = (q,xk,L) movimento para a esquerda



o (q,xk) = (q,xk,R) movimento para a direita

Beaver (1995) também estendeu este método para simular máquinas de Turing

não-determinísticas.

C = (xk1qxkxk+1); e(xk1,k1)e(q,k)e(xk,k)

C = (xk2qxk1xk); e(q,k1)e(xk1,k1)e(xk,k)

. . . . . .

q

xk2 xk1 xk xk+1

q

xk2 xk1 xk xk+1

. . . . . .

Figura 33: Codificação de uma configuração da máquina de Turing.



Polymerase extension Ligation

L A U E R

Ā Ō Ē R Mix

Anneal

U

L A E R

Ā Ē Ō

R

Ā Ē Ō

R

U

L A E R

L Ā Ē

Ō R

U

L A E R

L

L Denaturing

Mix with L

Anneal

L A O E R

L Ā Ō Ē R

Polymerase extension Destruction of the original strand

Figura 34: Substituição molecular de uma seqüência de DNA empregada como transição de

estados de uma “máquina de Turing de DNA”. Exemplo: substituir U por O.



6. Escopo da Computação de DNA

A computação de DNA foi inicialmente proposta para resolver problemas e

demonstrou ser bem sucedida na solução de problemas NP-completos.

Como qualquer instância de um problema NP-completo pode ser expressa em

termos de um outro problema NP-completo, as soluções baseadas em computação

de DNA apresentadas fornecem implicitamente um poder computacional suficiente

para resolver qualquer problema na classe NP.

Exemplos de outros problemas que podem ser resolvidos por DNA:

o Graph coloring

o Shortest common superstring

o Integer factorization

o Protein conformation

o Maximum clique

o Etc.



Também são encontrados trabalhos na literatura aplicando DNA para a geração de

memórias associativas, solução de problemas criptográficos, desenvolvimento de

algoritmos baseados em DNA para adição de números e multiplicação de matrizes,

máquinas paralelas, e implementação em computadores de DNA ou hibridização

de diversos paradigmas de computação natural.

O paralelismo massivo e a miniaturização do DNA sugerem uma vasta gama de

problemas que são candidatos em potencial a serem resolvidos pela computação de

DNA.

Além destas aplicações computacionais da computação de DNA, ela também pode

ser aplicada no domínio da biologia. Exemplos:

o Processamento de DNA: sequenciamento e fingerprinting

o Decodificação de material genético

o Criação e busca em bases de dados de DNA

o Detecção de mutações



Possíveis resultados desta pesquisa em problemas da biologia:

o Erradicação de doenças

o Identificação de criminosos, dentre outras

o Desenvolvimento de biochips implantáveis

7. Discussão

O experimento de Adleman foi rapidamente seguido por uma grande quantidade de

generalizações e extensões para a solução de outros problemas NP-completos.

Entretanto, é interessante notar que boa parte dos autores não implementaram a

computação de DNA em laboratório como feito por Adleman.

Na verdade, boa parte das propostas de soluções baseadas em DNA são de cunho

teórico, uma atividade denominada de menmology (mental molecular biology) por

Rozenberg.



As questões em aberto sobre a computação de DNA não mais dizem respeito ao

seu poder de processamento.

o Ao invés disso, a principal questão que permanece é quanto ao projeto e

construção de um computador de DNA.

o Neste sentido são dois os problemas centrais: correção de erros e realização

e automação das ténicas de manipulação de DNA.

Um dos grandes problemas da computação de DNA é que erros são muito comuns

em reações e processos biológicos. As operações de extração, annealing, merge e

muitas outras são imprecisas.

Tem sido grande o esforço no sentido de aproveitar conceitos de matemática e

biologia molecular para projetar computadores de DNA.

No estado atual, a computação molecular possui diversos desafios:

o O material utilizado (DNA, RNA ou proteínas) não é reutilizável

o Os componentes moleculares são especializados



o Correção de erros

o Para que um computador de DNA seja eficiente, o algoritmo a ser utilizado

deve ser o mais paralelizável possível

o A interface de entrada/saída é um tanto complicada

o O tempo experimental ainda é grande, mas isso pode ser remediado com um

aprofundamento dos conhecimentos e tecnologias em biologia molecular e

engenharia genética

Entretanto, algumas características da computação de DNA servem para

contrabalançar as dificuldades de projeto de um computador de DNA:

o Alta velocidade de processamento paralelo quando automatizado (permite o

uso da força bruta)

o É economicamente barato sob o ponto de vista de consumo de energia,

armazenagem e processamento de informação



Bibliografia

Păun, G., Rozenberg, G. and Saloma, A. (1998), DNA Computing: New Computing Paradigms,

Springer-Verlag.

Pisanti, N. (1998), “DNA Computing: A Survey”, Bulletin of the European Association for

Theoretical Computer Science, 64, pp. 188–216.

Gramß, T., Bornholdt, S., Groß, M., Mitchell, M. and Pellizzari, T. (2001), Non-Standard

Computation: Molecular Computation – Cellular Automata – Evolutionary Algorithms –

Quantum Computers, Wiley-VCH.

Calude, C. S. and Păun, G. (2001), Computing with Cells and Atoms, Taylor & Francis.

Amos, M. (2003), Theoretical and Experimental DNA Computation, Springer-Verlag.

Adleman, L. M. (1994), “Molecular Computation of Solutions to Combinatorial Problems”,

Science, 226, November, pp. 1021-1024.

Roweis, S., Winfree, E., Burgoyne, R., Chelyapov, N. Goodman, M., Rothemund, P. and

Adleman, L. (1996), “A Sticker Based Model for DNA Computation”, In E. Baum, D. Boneh,

P. Kaplan, R. Lipton, J. Reif and N. Seeman (eds.), DNA Based Computers, Proc. of the 2nd

Annual Meeting, pp.1-27.

Beaver, D. (1995), “Molecular Computing”, Technical Report TR 95-001, Penn. State

University, Pennsylvania, USA, January.



Tópico 6: Computação Quântica

20. Introdução e Motivação

Para calcular a posição, velocidade, energia e massa de um objeto em movimento,

aplicamos as leis da Física de Newton.

Um estudo similar em escala atômica e molecular requer um tipo de física

diferente, denominada de física quântica.

o A física quântica é a parte da física que estuda e explica o comportamento de

objetos com dimensões atômicas.

o Mecânica quântica é a terminologia usada para se referir ao formalismo

matemático que descreve a física quântica. Ela incorpora novos princípios na

física clássica: quantização da energia, dualidade, incerteza e probabilidade.



A aplicação da mecânica quântica possui um impacto dramático na ciência e

engenharia da computação, pois a tecnologia usada atualmente para projetar e

explicar o funcionamento de um computador é baseada na mecânica clássica.

Como a miniaturização dos componentes eletrônicos resultará naturalmente em

dimensões atômicas, a mecânica quântica tornar-se-á uma das poucas teorias

capazes de promover novos avanços na tecnologia computacional.

o Juntamente com a computação molecular, os computadores quânticos estão

entre as principais promessas de novos paradigmas de computação.

A computação quântica trata da computação com sistemas quânticos, resultando

nos chamados computadores quânticos, e não de física quântica computacional.

o Um computador quântico, entretanto, pode ser usado para modelar diversos

fenômenos quânticos mais eficientemente que computadores clássicos.

Similarmente a computação de DNA, a computação quântica possui como

principais vantagens o aumento massivo no poder computacional (devido



principalmente ao paralelismo quântico) e a armazenagem econômica de

informação.

Quando comparada à computação tradicional, a computação quântica oferece

algumas características únicas:

o Ela usa bits quânticos, qubits, como estrutura de dados. Portanto, um qubit pode

assumir qualquer valor lógico 0, 1 ou uma sobreposição deles.

o Os computadores quânticos podem operar de forma paralela.

o A computação pode ser feita em escala atômica, uma dimensão que

potencialmente limitará a tecnologia atual da indústria de silício.

o A tecnologia quântica suporta um tipo de computação completamente novo,

com algoritmos qualitativamente diferentes baseados em mecânica quântica.

o Os computadores quânticos são extremamente eficientes na solução de

problemas NP-completos.



21. Conceitos Básicos da Teoria Quântica

21.1. Da Mecânica Clássica à Mecânica Quântica

Até o início do século 20, os físicos eram capazes de explicar fenômenos naturais

usando duas amplas teorias: as Leis da Mecânica de Newton e o

Eletromagnetismo de Maxwell.

Em conjunto eles constituem a chamada física clássica:

o A mecânica de Newton estuda o movimento dos corpos, como as órbitas dos

planetas e a trajetória de projéteis.

o O eletromagnetismo de Maxwell estuda os fenômenos eletromagnéticos, como

a luz e as ondas de rádio.

O poder da mecânica clássica parecia tão grande durante os séculos 18 e 19 que

um dos sucessores de Newton, P. Laplace, sugeriu que dado o completo

conhecimento de todas as partículas de um sistema num dado instante de tempo e



um poder de cálculo ilimitado, seria possível prever o futuro e ‘retrodizer’ o

passado.

Entretanto, a física clássica não era capaz de explicar todos os tipos de fenômenos.

Várias observações experimentais pareciam apresentar resultados contraditórios.

o Um exemplo clássico é a observação de que a mesma radiação que produz

interferência e, portanto, deve se comportar como onda, também resulta no

efeito fotoelétrico e, portanto, deve consistir de partículas.

As tentativas de descrever eventos atômicos usando mecânica clássica resultavam

em contradições, pois átomos e moléculas a distâncias curtas não se comportam

seguindo as leis da mecânica clássica.

Uma nova e consistente formulação teórica começou então a ser desenvolvida na

física.

Ao final do século 19 o físico alemão Max Planck fez uma descoberta

extraordinária.



o Ele descobriu que a radiação é emitida ou absorvida de tempos em tempos em

pacotes de energia de tamanho definido, chamados de quanta.

o Ele propôs que o conteúdo de energia, E, de de um destes quanta seria

proporcional à frequência de radiação, v, com uma constante de

proporcionalidade h, conhecida atualmente como constante de Planck:

E = h.v, h = 6.6260751034 J.s,

Alguns anos depois, em 1905, Einstein confirmou a teoria de Planck usando-a

para explicar o efeito fotoelétrico, considerado mais uma ‘anomalia’ na física:

o Os elétrons contidos em um metal podem se mover dentro dele, mas não

possuem energia suficiente para escapar do metal.

o O efeito fotoelétrico acontece quando um feixe de luz expulsa elétrons de

dentro do metal. Isso ocorre porque a radiação transfere energia para os elétrons

presos dentro do metal e, se o ganho for suficiente, um elétron pode escapar das

forças que o mantém preso dentro metal.



o De acordo com o pensamento clássico, o coeficiente de emissão de elétrons

dependeria da intensidade do feixe de luz bombardeando o metal, pois a luz era

vista como uma onda eletromagnética.

o Entretanto, observações experimentais indicaram que a emissão de elétrons

dependia da frequência e não da intensidade da luz.

o Uma forma de resolver este dilema seria assumindo que a luz consiste de

pequenas partículas ou quanta, denominados de fótons, com uma energia

proporcional à constante de Planck vezes a frequência.

o Sob esta perspectiva, um elétron poderia ser ejetado após a colisão com um

fóton e depois liberar toda sua energia. A intensidade do feixe de luz influencia

o número de fótons emitidos e, portanto, o número de elétrons ejetados, mas

apenas a frequência influenciaria a expulsão de elétrons.

Várias outras observações experimentais e teorias contribuíram para o

desenvolvimento da mecânica quântica durante o século 20.



21.2. A Dualidade Onda-Partícula

Antes de apresentar o formalismo matemático da mecânica quântica, vamos

apresentar mais uma ‘anomalia’ da física.

Vamos considerar três diferentes versões de um experimento famoso que servirá

para ilustrar algumas diferenças entre o mundo macroscópico e o mundo

microscópico: o experimento das duas fendas (double-slit experiment).

Experimento utilizando balas:

No primeiro cenário há uma metralhadora que atira aleatoriamente com

velocidade constante em direção a uma parede com duas fendas.

Um escudo detector é posicionado atrás da parede com duas fendas e fica

responsável por identificar o local onde as balas irão atingir.

Após algum tempo de experimento é possível observar um padrão de chegada das

balas em relação à parede.

O mesmo experimento é feito mantendo uma das fendas fechada de cada vez.



Com ambas as fendas abertas ao mesmo tempo é possível observar que o padrão

resultante é a soma dos padrões obtidos com cada uma das fendas abertas de uma

vez.

Slit 1

Slit 2

Global optimum (minimum) (a) (b) (c)

Figura 35: Experimento da fenda dupla com balas.



Seja P12 a probabilidade de chegada das balas com ambas as fendas abertas, P1 a

mesma probabilidade com apenas a fenda 1 aberta e P2 a probabilidade com

apenas a fenda 2 aberta:

o P12 = P1 + P2.

Experimento utilizando ondas de água:

Neste segundo cenário existe um lago com uma fonte de ondas, uma barreira com

duas fendas e um detector atrás da barreira capaz de medir a quantidade de energia

da onda naquela posição.

Quando ambas as fendas estão abertas ao mesmo tempo, é possível observar

interferência entre as ondas.

Este é um fenômeno conhecido de todos, por exemplo, quando jogamos pedras em

um lago notamos que as ondas interferem umas nas outras.

A energia das ondas em uma dada posição está relacionada com sua intensidade

naquela posição: ela depende do quadrado da altura máxima da onda.



Diferentemente do experimento com balas, o mesmo padrão de onda não pode ser

obtido somando-se os padrões obtidos com uma única fenda aberta de cada vez.

Gap 1 Gap 2


Figura 36: Experimento da fenda dupla com ondas.



Seja I a intensidade da onda (ou seja, quantidade de energia chegando por

segundo) e H a altura máxima da onda:

I = H2.

Seja H1 a altura da onda proveniente da fenda 1 quando a fenda 2 está fechada e

H2 a altura da onda proveniente da fenda 2 quando a fenda 1 está fechada,

chegamos na seguinte relação:

I12 = 2

12H = (H1 + H2)2.

Onde I12 é a intensidade da onda com ambas as fendas abertas, que é diferente de

I1 + I2, e H12 = H1 + H2 é a altura quando ambas as fendas estão abertas.

Experimento utilizando elétrons:

Considere, por último, o caso de um dispositivo que dispara elétrons montado em

frente a uma fina barreira metálica com duas fendas bem estreitas e uma placa

detectora carregada com uma substância química que emite flashes de luz cada

vez que um elétron se choca com ela.



Um fato importante sobre os elétrons é que eles são partículas, ou seja, eles

possuem massa bem definida, carga elétrica, spin, etc.

Neste cenário é possível contar o número de flashes em dadas posições do detector

durante algum período de tempo, um padrão comportamental similar àquele das

balas.

Para cada uma das fendas abertas de forma independente, o padrão obtido é

exatamente o mesmo daquele apresentado pelas balas.

Quando ambas as fendas estão abertas simultaneamente, entretanto, é possível

obter um padrão de interferência similar ao obtido com as ondas de água.

Há locais na placa detectora onde nenhum elétron atinge e há locais onde mais

elétrons atingem do que o esperado a partir da soma das contribuições com cada

fenda aberta individualmente.



Este resultado corresponde a um dos mistérios centrais da mecânica quântica:

objetos quânticos, assim como elétrons, possuem atributos que permitem

classificá-los como onda e partícula, mas se comportam como nenhum deles.

Slit 1 Slit 2


Figura 37: Experimento da fenda dupla com elétrons.



Baseado neste comportamento dual, no caso dos elétrons é preciso medir sua

probabilidade de chegada e também levar em consideração uma espécie de ‘altura

de uma onda de elétron’.

Como o quadrado desta altura deve corresponder à probabilidade, ela é chamada

de probabilidade de amplitude quântica (quantum probability amplitude).

Portanto, a equação para a probabilidade de chegada de elétrons terá a mesma

forma das ondas de água, mas a intensidade será substituída pela probabilidade P e

a altura será substituída pela amplitude a:

P12 = (a1 + a2)2. Neste caso P12 P1 + P2.

A dualidade onda-partícula corresponde, portanto, ao fato de que os elétrons,

assim como a luz, apresentam interferência em sua chegada, mesmo chegando em

‘flashes’.



(a) (b)

Figura 38: Interferência gerada com um laser em um experimento de fenda dupla. (a) Pequena

separação entre as fendas. (b) Ampla separação entre as fendas.

21.3. O Princípio da Incerteza

No nível quântico há claramente um limite fundamental para a precisão que pode

ser atingida para se observar (medir) algo.

No caso do experimento da fenda dupla, só é possível prever com alguma

probabilidade se um elétron vai atingir uma dada posição do detector, pois sempre

que uma medida for feita o sistema é perturbado.

Isso ocorre porque para observar um elétron é preciso usar um feixe de luz sobre

ele e observar a luz refletida.



Como os elétrons são objetos quânticos delicados, quando a luz interage com os

elétrons ela perturba seu movimento de forma significativa.

Esta perturbação é suficiente para eliminar o padrão de interferência entre os

elétrons no experimento, permitindo a determinação precisa da fenda pela qual o

elétron passa.

Neste caso, o padrão resultante é exatamente aquele observado usando balas, o

que significa que ao incidirmos luz no elétron ele se comporta como uma

partícula.

De forma ampla, o princípio da incerteza significa que quanto mais precisamente

a posição de um objeto é determinada, menos precisamente seu momento é

conhecido em um dado instante de tempo, e vice-versa.

Portanto, as leis da física quântica impõem uma certa limitação fundamental na

precisão das medidas experimentais.



Para os objetos no mundo quântico a perturbação causada pelos dispositivos de

medição não é desprezível.

21.4. Alguns Comentários

Baseado nas discussões apresentadas até aqui, algumas conclusões importantes

relativas à física quântica podem ser feitas:

o A luz pode apresentar um comportamento de partícula e de onda, dependendo

da observação;

o A observação afeta o estado do sistema;

o O resultado de uma medição de um experimento quântico não pode ser previsto

com precisão, apenas probabilisticamente;

o Há um limite para a precisão dos dispositivos de medição;

o A evolução de um sistema se refere a como ele se comporta ao longo do tempo

e é diferente da medição.



Uma formulação matemática para descrever os sistemas quânticos deve levar em

consideração todos os aspectos acima: deve representar objetos físicos como

entidades matemáticas; deve modelar interferência; deve levar em consideração

comportamentos não-determinísticos; deve levar em consideração o efeito das

medições no comportamento do sistema; e deve considerar a evolução do sistema

de maneira diferente da observação (medição).

22. Princípios de Mecânica Quântica

A mecânica quântica é geralmente formulada usando uma de duas teorias:

o Mecânica de onda, proposta por E. Schrödinger, baseada em equações

diferenciais parciais para a descrição das ondas;

o Mecânica matricial, proposta por W. Heisenberg, que envolve o uso de

matrizes associadas às propriedades das matérias.

Uma outra formulação comum é a teoria da transformação proposta por P. Dirac,

que une as mecânicas matricial e de onda.



Nesta formulação, a ser apresentada aqui, o estado instantâneo de um sistema

quântico é descrito por um estado quântico que codifica as probabilidades

associadas a todos os observáveis, ou seja, propriedades mensuráveis.

22.1. A Notação de Dirac

Um vetor é representado por

|x, (1)

onde x é o rótulo do vetor.

A notação |, conhecida como ket, indica que x é um vetor coluna.

Cada ket possui um bra x| dual, que corresponde ao conjugado transposto do ket

|x: x| = |x†.

O estado de um sistema quântico é descrito por um vetor de norma unitária em um

espaço de Hilbert, ou seja, um espaço vetorial complexo de dimensão n, Hn, que

corresponde ao espaço de estados do sistema.



O espaço de estados de um sistema quântico, conhecido como espaço de estados

quântico, pode ser descrito em termos de vetores e matrizes ou usando uma

notação padrão denominada de notação bracket (bra-ket) ou notação de Dirac.

A terminologia bracket deve-se ao fato de que o produto interno de dois estados é

representado por um bracket: y||x = y|x, cujo resultado é um número complexo.

O produto externo dos vetores |x e y| é representado por |xy| e resulta em uma

matriz.

Exemplo:

Seja a base ortonormal do espaço formada pelos vetores |x e |y, {|0,|1}.

Na notação usual da álgebra linear esta base poderia ser expressa por

{(1,0)T,(0,1)T} ou, alternativamente, {(0,1)T,(1,0)T}.

No primeiro caso, o produto interno 0|1 entre os vetores 0| e |1 é 0|1 = 0; e o

produto interno entre os vetores 0| e |0 é 0|0 = 1.

O produto externo dos vetores |1 e 0| é:



A = |10| =

01

00.

Note que o resultado do produto externo é uma matriz A que corresponde a uma

transformação nos estados quânticos que irá ditar o que acontece com os vetores

base.

o Por exemplo, o produto externo |10| mapeia |0 em |1 e |1 em (0,0)T.

22.2. Superposição Quântica

Qualquer estado de um sistema quântico pode ser escrito como uma combinação

linear de um certo número de estados base ou vetores base:

c1|x1 + c2|x2 + … + cn|xn, (2)

onde ci, i = 1,…,n são números complexos, denominados de amplitudes, e

i |ci|2 = 1, i.

Note que xi, i = 1,…,n, correspondem a observáveis de um objeto físico.



o Por exemplo, x1 pode representar a velocidade de uma partícula e x2 pode

representar seu momento.

A Equação (2) é conhecida como superposição dos estados base.

22.3. Produtos Tensores

O produto tensor de |x e |y, representado por |x|y, também abreviado por

|x|y ou |xy, é uma forma de unir espaços vetoriais na construção de espaços

vetoriais maiores; ele permite combinar estados quânticos.

Portanto, o espaço de estados de um sistema composto é o produto tensor dos

espaços de estado dos sistemas físicos componentes.

Exemplo:

Dados os estados base {|0,|1} = {(1,0)T,(0,1)T}, temos os seguintes produtos

tensores:

|0|0 = |00 = (1 0 0 0)T.

|0|1 = |01 = (0 1 0 0)T.



|1|0 = |10 = (0 0 1 0)T.

|1|1 = |11 = (0 0 0 1)T.

Para um escalar arbitrário c pertencente ao campo e alguns vetores x, x1, x2, y, y1,

e y2, pertencentes aos espaços apropriados, o produto tensor satisfaz as seguintes

propriedades básicas:

c(|x|y) = (c|x)|y = |x(c|y);

(|x1+|x2)|y = |x1|y + |x2|y;

|x(|y1+|y2) = |x|y1 + |x|y2.

22.4. Emaranhamento (Entanglement)

Dois bits clássicos podem ser unidos (combinados) em um sistema composto da

forma 00, 01, 10, 11.

O valor de qualquer combinação pode ser escrito como o produto dos bits

individuais.



Há alguns sistemas quânticos compostos que não podem ser escritos como o

produto tensor dos estados de seus sistemas componentes, uma propriedade

chamada de emaranhamento.

O espaço de Hilbert de um sistema composto por dois sistemas A e B é HAHB; ou

seja, é o produto tensor dos respectivos espaços.

Assumindo que o primeiro sistema está em um estado arbitrário |xA e o segundo

em um estado arbitrário |yB, se o estado do sistema composto não puder ser

escrito como o produto tensor |xA|yB, então os estados são ditos emaranhados;

caso contrário, eles são ditos separáveis, decomponíveis, ou estados produto.

A forma geral do estado de um sistema composto HAHB é:

yx xy yxc

,|| BA . (3)

Exemplos de estados emaranhados com dois qubits são os estados de Bell:

ABAB 11|00|2

1| 0x

;



ABAB 10|01|2

1| 1x

;

ABAB 11|00|2

1| 2x

;

ABAB 10|01|2

1| 3x .

Um exemplo de um estado decomponível é aquele formado pela combinação

linear de todos os estados base em H4: ½(|00+|01+|10+|11).

o Isso pode ser verificado encontrando-se os coeficientes a1, a2, b1, b2, tal que:

½(|00+|01+|10+|11) = (a1|0+a2|1)(b1|0+b2|1) =

= a1b1|00 + a1b2|01 + a2b1|10 + a2b2|11.

o Neste caso a1b1 = a1b2 = a2b1 = a2b2 = ½, que corresponde a a1 = a2 = b1 = b2 =

2/1 .



22.5. Evolução (Dinâmica)

A evolução de um sistema quântico corresponde a sua dinâmica, ou seja, como ele

varia ao longo do tempo.

Se um sistema quântico não está interagindo com outro sistema (é fechado), sua

evolução pode ser descrita por uma transformação unitária representada por uma

matriz.

Em outras palavras, o estado |x1 de um sistema no instante de tempo t1 está

relacionado ao estado |x2 no instante de tempo t2 por uma transformação unitária

A que é função de t1 e t2:

|x2 = A|x1. (5)

A ação da transformação unitária A sobre o estado x é descrita pela

correspondente rotação do vetor |x no espaço de Hilbert apropriado.

Portanto, a transformação unitária corresponde a operação da mecânica quântica e

também a uma rotação unitária.



Note que a ordem de aplicação de uma transformação influencia o resultado final:

A.B ≠ B.A, onde A e B são transformações unitárias.

Além disso, uma transformação unitária significa que a evolução no tempo de um

sistema quântico é inversível (reversível), ou seja, |x1 pode ser perfeitamente

recuperado a partir de |x2.

Exemplos de transformações unitárias são as matrizes de Pauli:

0 = I =

10

01

1 = X =

01

10

(6)

2 = Y =

0

0

i

i

3 = Z =

10

01

A aplicação do operador X, por exemplo, aos vetores base {|0,|1} mapeia |0 em

|1 e |1 em |0, respectivamente; agindo, portanto, como uma espécie de porta

NOT.



Portanto, é possível concluir que um operador unitário pode ser visto como uma

espécie de porta quântica (quantum gate).

22.6. Medição

Em várias ocasiões é necessário medir ou observar o comportamento do sistema

para que seja possível caracterizá-lo, por exemplo, verificar seu estado.

Uma medição quântica é descrita por um conjunto de operadores que atuam sobre

o espaço de estados do sistema sendo observado.

Qualquer dispositivo de medição de um sistema quântico possui uma base

ortonormal associada em relação a qual a medição será feita. O resultado será a

projeção do estado do sistema antes da medição no subespaço do espaço de

estados compatível com os valores medidos; ou seja, a medição projeta (promove

o colapso) do estado quântico em um dos estados base associados ao dispositivo

de medição. A amplitude da projeção é re-escalonada de forma que o vetor

resultante tenha norma unitária.



Note que o resultado de uma medição é probabilístico e muda o estado do sistema

para aquele estado medido.

Exemplo:

Seja um estado arbitrário |x representado pela combinação linear dos estados base

|0 e |1: |x = c1|0 + c2|1, onde c1 e c2 são números complexos.

A medição do estado |x = c1|0 + c2|1 resulta em |0 com probabilidade |c1|2 e em

|1 com probabilidade |c2|2.

O aspecto mais importante aqui é que observar |x implica em interagir com |x, o

que possui o efeito de promover um colapso do estado do sistema em um dos

estados base.

Portanto, de acordo com o princípio da incerteza de Heisenberg, observar um

estado quântico causa uma perturbação no mesmo.



|1

|0

|x

c1

c2 |1 |0

|x

c1 c2

(a)

(b)

Figura 39: Pares de bases associadas a diferentes dispositivos de medição e a projeção de |x

nos estados base. (a) Base: {|0,|1} = {(1,0)T,(0,1)}. (b) Base:

{|0,|1} = {(1/2,1/2)T,(1/2,1/2)}.

22.7. Teorema ‘No-Cloning’

O teorema chamado de no-cloning afirma que não é possível criar cópias idênticas

de um estado quântico arbitrário desconhecido, ou seja, não há uma máquina para

se copiar estados quânticos.



Para provar o teorema, assuma um sistema quântico A em um espaço de Hilbert

bidimensional H2 com estados base |0A e |1A.

Um estado arbitrário |xA deste sistema quântico pode ser escrito como uma

combinação linear dos estados base: |xA = c1|0A + c2|1A.

Suponhamos que o objetivo seja copiar o estado |xA.

A máquina para copiar estados quânticos deverá receber como entrada |xA e

apresentar como saída |xA duas vezes.

Para fazer a cópia, um sistema B com um espaço de Hilbert idêntico e um estado

inicial arbitrário |sB é tomado.

O estado inicial |sB do sistema B será transformado no estado a ser copiado.

O seguinte estado inicial resulta da máquina de copiar estados:

|xA|sB. (8)



O sistema composto pode ser observado, o que promoveria um colapso para um

dos estados base do medidor, ou ser submetido a uma transformação unitária

arbitrária A que seria responsável por copiar o estado |xA:

A(|xA|sB) = |xA|xB =

= (c1|0A + c2|1A) (c1|0B + c2|1B) = (9)

= (c12|0A|0B + c1c2|0A|1B + c2c1|1A|0B + c2

2|1A|1B).

No caso particular em que queremos copiar os estados base de um sistema

quântico bidimensional:

A(|0A|sB) = |0A|0B. (10)

A(|1A|sB) = |1A|1B.

Aplicando a copiadora ao estado genérico |x, assumindo a linearidade da

transformação A, e considerando a Equação (10), tem-se:

A(|xA|sB) = A(c1|0A + c2|1A)|sB =

= A(c1|0A|sB + c2|1A|sB) = (11)



= A(c1|0A|sB) + A(c2|1A|sB) =

= c1|0A|0B + c2|1A|1B.

Que é diferente do resultado obtido na Equação (9).

o Portanto, genericamente A(|xA|sB) ≠ |xA|xB.

23. Informação Quântica

Para introduzir os fundamentos do processamento de informação quântica,

primeiro definiremos a unidade básica de informação, apresentaremos meios de

processar estas unidades, e estenderemos para os casos de múltiplas unidades de

informação.

23.1. Bits e Bits Quânticos

Em computação e teoria da informação, a unidade mais básica de informação é o

dígito binário ou bit, que corresponde a uma entidade abstrata que pode assumir

um dos valores lógicos ‘0’ ou ‘1’.



A informação é fisicamente armazenada como bits nos computadores clássicos e

os dispositivos que implementam os bits podem ser uma combinação de

transistores ou outros elementos de circuitos integrados com uma distribuição de

carga que determina o estado do bit.

Os bits podem ser organizados em sentenças de comprimento n, permitindo a

representação de uma quantidade maior de informação e as cadeias binárias

podem ser manipuladas para realizar computação, por exemplo, implementar

algoritmos.

É possível acessar um certo endereço de memória de um computador clássico e

observar (ler) seu conteúdo.

Quando a informação é armazenada em escala atômica, os efeitos quânticos

aparecem e o resultado é um cenário completamente diferente.

Neste caso, um bit quântico, ou qubit, pode assumir ambos os valores ‘0’ e ‘1’

simultaneamente.



Os qubits são objetos matemáticos (entidades abstratas) com propriedades

específicas e correspondem as unidades mais básicas de informação em

computação quântica.

Eles são representados por um sistema quântico ideal de dois estados, como fótons

polarizados, elétrons, átomos, íons ou spins nucleares.

Slit 1

Figura 40: Representação de um átomo com três níveis discretos de energia, de acordo com a

mecânica quântica. Um átomo representado apenas com os dois níveis internos de energia pode

representar um bit quântico.

A informação quântica é descrita por um estado em um sistema quântico com dois

estados básicos nomeados, por convenção, |0 e |1.



Estes estados particularmente formam uma base ortonormal de um espaço vetorial

complexo bidimensional (um espaço de Hilbert H2) e, portanto, são conhecidos

como estados computacionais base (computational basis states).

Sendo assim, é possível fazer combinações lineares dos estados base,

denominadas superposição, que correspondem a um estado de um qubit puro:

|x = c1|0 + c2|1, (12)

onde c1 e c2 são números complexos.

Na prática, a superposição de estados quânticos significa que uma quantidade

infinita de informação pode, potencialmente, ser codificada em um único qubit.

Basta definir apropriadamente os coeficientes c1 e c2.



Slit 1 Slit 2

|0

|1

|x

0

1

States

Bit Qubit

23.2. Múltiplos Bits e Qubits

Na computação clássica, N bits podem ser usados para representar 2N estados

distintos.

Um sistema quântico com N qubits possui N estados computacionais base,

denotados por:

1...11

000

||...x

x xcy , (13)



onde cx são números complexos tais que x |cx|2 = 1.

Portanto, N qubits podem representar qualquer vetor complexo unitário em um

espaço de Hilbert de dimensão 2N, possuindo uma dimensão para cada estado

clássico.

o Ou seja, qualquer vetor neste espaço de dimensão 2N pode ser representado por

uma combinação linear dos estados base.

o Isso corresponde a um crescimento exponencial do número de possíveis estados

de um sistema quântico em comparação aos sistemas clássicos.

o Um sistema ordenado de N qubits é conhecido como um registrador quântico.

Os estados quânticos são combinados através de produtos tensores, responsáveis

pelo crescimento exponencial do número de estados possíveis.

Exemplo:

Considere o espaço de estados de um sistema quântico com dois qubits, cada qual

com uma base computacional clássica {|0,|1}.



A base do espaço de estados resultante é {|0|0, |0|1, |1|0, |1|1},

também representada por {|00, |01, |10, |11}.

Assumindo a base padrão da álgebra linear em H2, a base em H4 torna-se:

0

0

0

1

00|,

0

0

1

0

01|,

0

1

0

0

10|,

1

0

0

0

11|.

23.3. Portas Lógicas e Portas Quânticas

As operações elementares para manipular bits em computadores clássicos são

chamadas de funções ou operações lógicas.

Uma porta lógica é um dispositivo eletrônico usado para realizar uma função

lógica simples e para construir sistemas lógicos maiores.

As operações realizadas pelas portas lógicas clássicas geralmente são não-

inversíveis.



Exemplo:

AND NOT

OR NAND

XOR NOR

a

b

a

b

a

b

a

a

b

a

b

a b a AND b a b a OR b a b a XOR b

0 0 0 0 0 0 0 0 0

0 1 0 0 1 1 0 1 1

1 0 0 1 0 1 1 0 1

1 1 1 1 1 1 1 1 0

a NOT a a b a NAND b a b a NOR b

0 1 0 0 1 0 0 1

1 0 0 1 1 0 1 0

1 0 1 1 0 0

1 1 0 1 1 0

Figura 41: Portas lógicas dos computadores clássicos e suas respectivas tabelas-verdade.



As portas quânticas constituem as unidades básicas dos algoritmos quânticos e,

portanto, dos computadores quânticos.

O exemplo mais simples de uma porta quântica que atua em um único qubit é a

porta NOT quântica, que faz o seguinte mapeamento: |0 |1 e |1 |0:

NOT |0 = X|0 =

1

0

0

1

01

10

|1, (14)

NOT |1 = X|1 =

0

1

1

0

01

10

|0.

Esta operação (NOT) é representada pela matriz X.

Qualquer transformação matricial unitária pode ser usada como uma porta

quântica e, portanto, as portas quânticas são reversíveis (inversíveis).



A necessidade da unitariedade da transformação vem do fato de que dado um

estado quântico arbitrário |y = c1|0 + c2|1 obtido a partir de |y = c1|0 + c2|1,

os coeficientes |c1|2 + |c2|

2 = 1.

As matrizes de Pauli estudadas na revisão matemática correspondem a portas

quânticas conhecidas.

0 = I =

10

01

1 = X =

01

10

2 = Y =

0

0

i

i

3 = Z =

10

01

I: porta identidade; X: porta NOT e Z: porta mudança de fase.

Outras portas quânticas:

Raiz quadrada do NOT:

NOT |0 = ½(1+i)|0 + ½(1i)|1,



NOT |1 = ½(1i)|0 + ½(1+i)|1,

ii

ii

11

11

2

1NOT , (15)

NOT . NOT = NOT.

Porta de Hadamard:

H =

11

11

2

1. (16)

Obs.: quando aplicada a N bits individualmente, a porta de Hadamard gera uma

superposição de todos os 2N possíveis estados:

H|0 = )1|0(|2

1

1

1

2

1

0

1

11

11

2

1

, (17)

H|1 = )1|0(|2

1

1

1

2

1

1

0

11

11

2

1

.

NOT controlado:



CNOT =

0100

1000

0010

0001

. (18)

Dado um estado de entrada |x1x2, x1, x2 {0,1}, a saída produzida pela porta

CNOT é |x1x3, x3 = x1 x2, onde é a adição módulo 2 (operação XOR).

CNOT |00 = |00

CNOT |01 = |01

CNOT |10 = |11 (19)

CNOT |11 = |10

Uma propriedade importante da parta CNOT é que ela pode ser usada para criar

emaranhamento. Exemplo:

CNOT2

1(|00 + |10) =

2

1(|00 + |11).



Porta de Toffoli ou controlled-controlled-NOT:

CCNOT |000 = |000

CCNOT |001 = |001

CCNOT |010 = |010

CCNOT |011 = |011

CCNOT |100 = |100

CCNOT |101 = |101

CCNOT |110 = |111

CCNOT |111 = |110

01000000

10000000

00100000

00010000

00001000

00000100

00000010

00000001

CCNOT

(20)

23.4. Circuitos Quânticos

Circuitos quânticos correspondem a descrições gráficas de uma ou mais

transformações quânticas.

Exemplo:



NOR

|x |x

|y |xy

Figura 42: Circuito quântico para a porta CNOT.

É possível combinar a porta CNOT de várias maneiras.

Exemplo:

|x |x |(xy)x = |y |y

|y |xy |xy |y(xy) = |x

Figura 43: Circuito quântico combinando várias portas CNOT.

O que o circuito acima faz?

Outras representações para circuitos quânticos específicos:



H S T

Figura 44: Circuitos quânticos para as portas de Hadamard, mudança de fase e Toffoli.

Os estados Bell, também denominados de pares EPR, podem ser gerados por uma

combinação de uma porta Hadamard aplicada ao primeiro qubit seguido de uma

porta controlled-NOT:

H x

y

|xy

Figura 45: Circuito quântico para gerar os estados Bell (pares EPR).

Estado inicial H(primeiro qubit, x) CNOT(primeiro qubit, x)

|00 0|1|0|21 11|00|21

|01 1|0|1|21 01|10|21

|10 0|1|0|21 11|00|21

|11 1|1|0|21 10|01|21



24. Exemplos de Aplicação

A Codificação Densa (dense coding) e o Teletransporte (teleportation) servem

para ilustrar o uso de portas quânticas simples.

Ambos os exemplos assumem o mesmo cenário inicial:

o Alice e Bob nunca se comunicaram e querem fazê-lo.

o Para isso eles usam um aparato que gera pares emaranhados de qubits (estados

Bell) como, por exemplo,

11|00|2

1| 0x . (21)

o Um qubit é enviado a Alice e outro a Bob. Alice só pode aplicar transformações

em seu respectivo qubit e Bob em seu, até que uma partícula seja transmitida.

24.1. Codificação Densa

A codificação densa corresponde ao método pelo qual Alice pode comunicar dois

bits clássicos enviando apenas um qubit a Bob.



Dois qubits estão envolvidos, mas Alice enxerga apenas um deles.

Alice recebe dois bits clássicos e codifica os números 0, 1, 2 e 3.

Estes números corresponderão a uma das quatro transformações unitárias

{I,X,Y,Z}, e atuarão no primeiro bit do par emaranhado da Alice x0.

I =

10

01

X =

01

10

Y =

01

10

Z =

10

01

Valor codificado Estado inicial Transformação Novo estado

0

|x0 = 11|00|2

1

(I I) |x0 11|00|21

1 (X I) |x0 01|10|21

2 (Y I) |x0 01|10|21

3 (Z I) |x0 11|00|21



Em seguida Bob aplica uma porta CNOT nos pares emaranhados resultantes,

obtendo um conjunto de pares decomponíveis.

Desta forma, Bob pode medir o segundo qubit sem perturbar o estado quântico.

Aplicando uma porta Hadamard no primeiro qubit resultante da aplicação do

CNOT torna-se possível identificar os bits enviados.

Estado inicial CNOT |xi H(1º. qubit)

|x0 = 11|00|21 0|1|0|2110|00|21 |0

|x1 = 01|10|21 1|0|1|2101|11|21 |0

|x2 = 01|10|21 1|0|1|2101|11|21 |1

|x3 = 11|00|21 0|1|0|2110|00|21 |1

A codificação densa pode ser realizada através do circuito apresentado abaixo:



x

y

|00

H

H Meas

Meas

T x

y

Figura 46: Circuito quântico para realizar a codificação densa.

24.2. Teletransporte Quântico

Assuma que Alice quer comunicar um qubit desconhecido |x a Bob.

o Devido ao teorema no-cloning, estados quânticos não podem ser copiados e

enviados sem serem destruídos.

o Além disso, se |x é desconhecido, qualquer tentativa de medi-lo irá destruí-lo.

o Portanto, a única forma de transmitir |x a Bob parece ser enviando um bit

clássico.

O teletransporte quântico constitui uma forma de realizar esta tarefa.



o Ele corresponde ao processo pelo qual Alice comunica um único qubit

desconhecido |x a Bob enviando apenas informação clássica.

Assuma que Alice e Bob possuem, cada um, um qubit de um par EPR, e que Alice

controla o primeiro qubit do par EPR e Bob o segundo.

Alice interage o qubit a ser transmitido |x com sua metade do par EPR e depois

mede os dois qubits que ela possui, obtendo um de quatro possíveis resultados

{00,01,10,11}.

o Esta informação é posteriormente enviada a Bob através de um canal clássico,

que executa uma das quatro operações {I,X,Y,Z} na sua metade do par EPR, o

que o permite recuperar a informação enviada |x.

Seja |x = c1|0 + c2|1, |c1|2 + |c2|

2 = 1, o estado quântico desconhecido a ser

enviado e |x0 = 11|00|21 o par EPR que eles possuem.

O estado de entrada do sistema é o produto tensor entre |x e |x0:

|x0|x = (c1|0 + c2|1) 11|00|21 =



)11|00(|1|)11|00(|0|21 21 cc = (22)

111|100|011|000|21 2211 cccc .

Alice aplica agora o passo de decodificação da codificação densa – uma porta

CNOT seguida de uma porta Hadamard – ao qubit desconhecido e a seu membro

do par emaranhado, o que corresponde a transformação (HII)(CNOTI):

(HII)(CNOTI)(|x0|x) =

101|110|011|000|21)( 2211 ccccIIH =

)01|10(|1|)11|00(|0|21)( 21 ccIIH =

)01|10)(|1|0(|)11|00)(|1|0(|21 21 cc = (23)

)0|1|(11|)1|0|(10|

)0|1|(01|)1|0|(00|21

2121

2121

cccc

cccc

.

Em seguida Alice mede seus dois qubits, promovendo um colapso do estado em

uma das quatro possibilidades {00,01,10,11}.



Este resultado é enviado a Bob, que o usa para descobrir qual das quatro

operações {I,X,Y,Z} ele deve aplicar a seu qubit para colocá-lo no estado

superposto |x = c1|0 + c2|1:

Bits recebidos Estado Transformação

00 c1|0 + c2|1 I

01 c1|1 + c2|0 X

10 c1|0 c2|1 Z

11 c1|1 c2|0 Y

|00

H

H Meas

Meas

|x T

|x

Figura 47: Circuito quântico para realizar teletransporte.



Nota: a palavra teletransporte ou teleporte é usada em ficção científica para

descrever o processo de mover objetos de um ambiente a outro codificando

informação sobre os objetos, transmitindo esta informação a outro local e depois

criando uma cópia dos objetos originais no novo local. O teletransporte quântico

possui este nome porque ele possui estas características em comum com a noção

fictícia de teletransporte: a) bits quânticos são codificados como bits clássicos; b)

a informação a ser transmitida é destruída durante o processo (devido a

observação); e c) o qubit transmitido é reconstruído a partir dos bits clássicos e do

par EPR.

25. Computadores Quânticos Universais

O desenvolvimento da teoria da computação quântica é marcado por diversas

tentativas de descrever formalmente um Computador Quântico Universal Q.



Uma das primeiras tentativas foi apresentada por P. Benioff em 1980 com uma

proposta de uma máquina de Turing híbrida na qual uma parte clássica coexistia

com um componente quântico.

Posteriormente, em 1982, R. Feynman introduziu um simulador quântico universal

baseado em circuitos lógicos quânticos análogos aos circuitos clássicos.

Apesar destas propostas, é geralmente atribuído a D. Deutsch (1985) a proposta do

primeiro modelo real de um computador quântico.

25.1. O Computador de D. Deutsch

Deutsch propôs uma reinterpretação da tese de Church-Turing na qual as funções

computáveis são aquelas que, em princípio, podem ser computadas por um

sistema natural, em particular, um sistema físico.

Para isso, ele definiu um computador capaz de simular perfeitamente um

sistema físico , e propôs uma nova versão da tese de Church-Turing:



o “Qualquer sistema físico finitamente realizável pode ser perfeitamente

simulado por um modelo computacional universal que opera de forma finita.”

Nesta formulação, uma máquina que opera de forma finita é aquela que procede

através de uma sequência de passos.

De acordo com Deutsch, esta formulação é melhor definida e mais física do que a

original, pois ela se refere exclusivamente a conceitos objetivos como observação,

preparação e sistemas físicos.

Deutsch, então, introduziu um modelo de um computador quântico universal

composto de dois elementos principais: um processador finito e uma memória

infinita, da qual apenas uma porção finita é usada.

A computação procede em passos com duração finita t e durante cada passo

somente o processador e uma parte finita da memória interagem, o restante da

memória permanece estático.



O processador consiste de M observáveis de 2-estados ňi, i ZM, onde ZM é o

conjunto de inteiros de 0 a M 1.

A memória consiste em uma sequência infinita ši, i Z de observáveis de dois

estados.

A posição do cabeçote da máquina de Turing é um observável ǒ Z.

O estado de um computador quântico universal Q é definido como sendo um vetor

unitário no espaço de Hilbert H gerado pelos autovetores de ǒ, ň e š rotulados

pelos correspondentes autovalores o, n e s, denominados estados base

computacionais de Q:

|o;n;s = | o;n0, n1,…, nM1;…,s1, s0, s1,…, (24)

A dinâmica de Q é controlada por um operador unitário A H, que especifica a

evolução de qualquer estado seguindo a Eq. (5):

|x2 = A|x1. (5)



O computador quântico universal Q pode simular não apenas qualquer máquina de

Turing, mas também qualquer outro computador quântico com uma precisão

arbitrária.

Além disso, Q pode simular diversos sistemas físicos, reais e teóricos, o que está

além do potencial dos computadores clássicos.

Três propriedades importantes do computador quântico merecem destaque:

o Dois estados consecutivos de Q nunca podem ser iguais após uma computação;

o Q não pode ser observado antes do final da computação;

o A dinâmica de Q é necessariamente reversível.



Apêndice: Fundamentos Matemáticos

26. Conjuntos e Operações com Conjuntos

Um conjunto pode ser definido como uma agregação de objetos. Os conjuntos são

descritos por letras maiúsculas do alfabeto romano expressas em itálico. Por

conveniência de notação, alguns conjuntos especiais são descritos por símbolos

específicos. Exemplos:

: conjunto dos números naturais

: conjunto dos números reais

C: conjunto dos números complexos

O estado lógico ou associação de um elemento x a um conjunto X qualquer é

representado por

x X: x pertence a X



x X: x não pertence a X

Um conjunto pode ser especificado listando-se seus elementos entre colchetes

},...,,{ 21 nX xxx

ou evidenciando uma ou mais propriedades comuns aos seus elementos

X2 = {x X1 tal que P(x) é verdade} ou X2 = {x X1: P(x)}

As principais operações entre conjuntos são:

União: 2121 ou : XXXX xxx ;

Interseção: 2121 e : XXXX xxx ;

21 XX (conjunto vazio) se X1 e X2 são conjuntos disjuntos.

O complemento de um conjunto X é representado por X e é definido na forma:

XX xx : .



S é um subconjunto de X, se x S implica x X. Neste caso, diz-se que S está

contido em X (S X) ou que X contém S (X S). Se S X e S não é igual a X,

então S é um subconjunto próprio de X.

EPC 1: Descreva formalmente os seguintes conjuntos:

a) O conjunto dos números 1, 10 e 100.

b) O conjunto dos inteiros maiores que 5.

c) O conjunto dos números naturais menores que 20.

d) O conjunto dos números pares.

e) O conjunto dos números primos.

f) O conjunto dos números racionais.

g) O conjunto formado pelo fatorial de um valor de entrada n.

EPC 2: Seja A = {a,b,c,d,e} e B = {f,a,c,g}, pergunta-se:

a) Algum conjunto é subconjunto do outro?

b) A B?



c) A B?

27. Sequências e Tuplas

27.1. Sequência

Uma sequência é uma lista ordenada de objetos. Exemplos:

(1,2,3,4,5,6,7,8,9), também representada por 1,2,3,4,5,6,7,8,9.

a1,a2,a3,... ou {an, n } ou simplesmente {an}.

Diferenças entre uma sequência e um conjunto:

Em uma sequência a ordem dos elementos importa;

Em uma sequência é permitida a repetição de elementos

27.2. Tuplas

Tupla é uma denominação dada a uma sequência finita.

A denominação k-tupla é usada para referenciar uma sequência com k elementos.

Se k = 2, então diz-se que temos um par.

Conjuntos e sequências podem ser elementos de outros conjuntos e sequências.



Neste caso dizemos que o conjunto potência (power set) de A é o conjunto de

todos os subconjuntos de A. Exemplo:

Se A é o conjunto {0,1}, então o conjunto potência de A é {,{0},{1},{0,1}}.

Se A e B são dois conjuntos, o produto Cartesiano ou produto cruzado de A e B,

denominado A B, é o conjunto de pares no qual o primeiro elemento é um

membro de A e o segundo é um membro de B.

28. Funções

Uma função é um objeto que estabelece uma relação entrada-saída, ou seja, toma

uma entrada e produz uma saída.

Uma mesma entrada sempre produz a mesma saída: f(a) = b.

As funções também são chamadas de mapeamento: f mapeia a em b.

O conjunto de possíveis entradas de uma função é chamado de domínio, D, e as

saídas formam um conjunto chamado imagem, I.

Notação: f : D I.



Exemplos:

Considere a função abs. Se estamos trabalhando com inteiros, então o domínio

e a imagem de abs são inteiros. Portanto, abs: Z Z.

Considere a função soma add. Se estamos trabalhando com inteiros, então

add: Z Z Z.

EPC 3: Descreva formalmente as seguintes sequências (ou seja, descreva um

elemento genérico das sequências):

a) 1, 1/2, 1/3, 1/4,1/5, 1/6,... b) ½, ¼,... c) 1, 1, 1, 1,...

d) Sequência de Fibonnaci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55,...

EPC 4: Dada a função f(x,y) = y3 x2 + x + 7, determine a imagem de f(x,y) para

x = {1,2,3,4,5,6,7} e y = {7,6,5,4,3,2,1}.

EPC 5: Desenhe os gráficos das seguintes funções:

a) f(x) = x2 b) f(x) = x2 2x 3 c) k modulo m ou k (mod m)

d) f(x) = log2(x) e) f(x) = 2x f) f(x) = x! (fatorial de x)



EPC 6: Para a função dada na Figura 1 determine o domínio e a imagem.

a

b

c

d

r

s

t

u

Figura 1: Função f.

29. Teoria dos Grafos

A teoria dos grafos é utilizada para estudar grafos e constitui uma ferramenta

poderosa em teoria da computação e também apresenta diversas aplicações

práticas, como em otimização combinatória.

Considere o mapa apresentado na figura abaixo ilustrando diversas cidades

brasileiras e suas possíveis conexões aéreas.



Cada cidade nesta figura corresponde a um vértice, ponto ou nó, e cada ligação

conectando os nós é denominada de arco.

Este tipo de objeto ou representação gráfica é denominado de grafo e representa

um conjunto de nós possivelmente ligados por arcos.

Um grafo G pode, portanto, ser definido como sendo um conjunto V de vértices

(nós) e um conjunto E de arcos ligando pares de vértices de V: G = V,E.

Dito de outra forma, um grafo é uma 2-tupla dada por G = V,E.

Portanto, V = {v0,v1,…,vN} é o conjunto de nós de G, e E = {(vi,vj) : i j} é o

conjunto de arcos de G.

Um caminho em um grafo G corresponde a uma sequência alternada de vértices e

arcos.

Quando não há ambiguidade, um caminho pode ser denotado pela sua sequência

de vértices (v0,v1,…,vN).

Um caminho é dito fechado se v0 = vN.



Um grafo é dito conexo quando há pelo menos um arco ligando cada um de seus

nós, ou seja, quando há um caminho entre quaisquer dois vértices.

x2*

Figura 2: Mapa do Brasil com algumas cidades representadas como nós em um

grafo e alguns arcos correspondentes às principais linhas aéreas entre as cidades.



Um grafo é dito direcionado quando há um sentido pré-definido de percurso no

grafo, ou seja, quando os arcos possuem um sentido específico.

Um grafo é dito ponderado se para cada arco e E um número não-negativo

denominado de peso ou comprimento de e, w(e) 0, é especificado.

Para um grafo não-ponderado, o comprimento de um caminho é dado pelo número

de arcos no caminho.

Para grafos ponderados, o comprimento ou peso de um caminho é determinado

pela soma dos pesos dos arcos do caminho.

Dois nós vi e vj são ditos adjacentes se há um arco e G conectando-os, ou seja,

e = {vi,vj}.

Um ciclo é um caminho fechado de comprimento 3 ou mais no qual todos os

vértices são distintos, exceto v0 e vN.

O grau de um nó é o número de arcos incidentes no nó.



A Figura 3 ilustra alguns conceitos importantes em teoria dos grafos. Para o grafo

G1, os conjuntos V1 e E1 são, respectivamente, V1 = {A,B,C,D,E} e

E1 = {(A,B),(A,C),(C,E),(E,D)}, e para o grafo G2 os conjuntos V2 e E2 são,

respectivamente, V2 = {A,B,C} e E2 = {(A,B),(B,C)}. Os grafos G1 e G2 são,

respectivamente, não-ponderados e não-direcionados, enquanto o grafo G3 é

direcionado e não-ponderado, e G4 é direcionado e ponderado. Somente o trafo G3

é não-conexo. O peso (comprimento) do caminho (D,E,B,F,C) de G4 é 10.

Se um grafo G é ponderado, ele pode ser representado por G = V,E,w, onde w(e)

é o peso do arco e, também representado por w(i,j): o peso do arco (i,j) que

conecta os nós i e j. Para o grafo G4 da Figura 3, w(D,E) = 5, w(E,B) = 2, etc.



A B A A C A C

C G1 B G2 B F G3 B F G4

E D C E D E D

3

2

1

2

5

4

1

Figura 3: Exemplos de grafos. G1: conexo, não-direcionado e não-ponderado. G2:

conexo, não-direcionado e ponderado. G3: não-conexo, direcionado e não-

ponderado. G4: conexo, direcionado e ponderado.

29.1. Exemplos de Problemas Combinatoriais com Representação em

Grafos

Problema do Caixeiro Viajante: Dado um conjunto de cidades, uma cidade de

origem e a matriz de custos de se viajar de uma cidade a outra, o problema do

caixeiro viajante visa encontrar a rota de custo mínimo de modo que o caixeiro



parta da cidade de origem, passe por todas as demais cidades e retorne em seguida

à cidade de origem.

1 2 3

4 5 6 7

8 9 10 11

12 13 14 15 16

17 18 19

21 22 23

24 25 26

27 28 29 30

31 32

x

y

x2*

20

Figura 4: Instância do caixeiro viajante.

Problema do Caminho Hamiltoniano: Um caminho entre dois nós (p. ex., cidades)

é dito Hamiltoniano se, dados um nó inicial vin e um nó final vout, existe uma



sequência de arcos direcionados e1, e2, … ez (ou seja, um caminho) iniciando em

vin, terminando em vout e passando por cada nó exatamente uma vez.

2

0

6

1

3

4 5

Figura 5: Instância do caminho Hamiltoniano.

EPC 7: Dado o seguinte grafo não-direcionado G = V,E, V = {1,2,3,4,5,6} e

E = {(1,2),(1,3),(1,5),(2,4),(2,5),(3,4),(3,6),(4,6),(5,6)}, faça:

a) Construa o grafo.

b) Determine o grau de cada nó.



EPC 8: Determine a quantidade de possíveis rotas dos grafos das Figuras 4 e 5.

Assuma grafos totalmente conectados e não-direcionados.

30. Alfabetos, Sentenças e Linguagens

Um alfabeto é um conjunto finito não-vazio de símbolos, normalmente

denominado pelas letras gregas ou . Exemplos:

= {a,b,c,...z};

= {0,1}.

Strings ou words, também conhecidas como cadeias de caracteres, sentenças ou

palavras, são estruturas importantes em ciência da computação.

As palavras são construídas a partir de um alfabeto finito, cujos membros são os

símbolos do alfabeto.

Uma palavra é gerada a partir de um alfabeto tomando-se uma sequência finita de

símbolos do alfabeto. Exemplos:

professor .



00110010101 .

Se w é uma palavra gerada pelo alfabeto , o comprimento de w, escrito |w|, é o

número de símbolos que ela contém.

A palavra de comprimento zero é chamada palavra vazia e é representada pela

letra grega épslon .

|| = 0.

A n-ésima potência de uma palavra w, wn, corresponde a sua repetição n vezes.

Exemplos:

Seja w = abc, então w4 = abcabcabcabc.

w, w0 = .

A concatenação de duas palavras v, w é a palavra formada por uma colocada em

seguida da outra. Exemplos:

Sejam v = nao e w = til, então vw = naotil.



O reverso, wR, de uma palavra w é a palavra escrita ao contrário (de trás para

frente).

Neste caso diz-se que w é um palíndromo. Exemplo:

Se w = arara, então wR = arara.

O fechamento (reflexivo) de um alfabeto , representado por *, é dado pelo

conjunto de todas as possíveis sequências que podem ser formadas a partir de ,

inclusive a palavra vazia.

O fechamento transitivo ou positivo de , representado por +, é dado por *{}.

Exemplos: Seja = {0,1}

* = {,0,1,00,01,10,11,000,...}

+ = {0,1,00,01,10,11,000,...}

Uma linguagem L é um conjunto finito ou infinito de palavras (sentenças).

Exemplos:

Linguagens naturais.



Linguagens de programação.

Formalmente, uma linguagem L sobre um alfabeto é um subconjunto de *:

L *. Exemplos:

Dado o alfabeto = {0,1}, a linguagem binária L = {,0,1,00,01,10,11,...}

A linguagem vazia, , é definida sobre qualquer alfabeto.

Uma linguagem finita é uma linguagem enumerável.

Formas de representação de uma linguagem:

Informal: especificação de restrições sobre o conjunto das possíveis

combinações dos diferentes elementos de um alfabeto para formar uma palavra

válida de L. Forma geral: L = {w | definição sobre w}

Formal: especificação usando expressões parametrizadas. Exemplo:

L = {0n1n | n > 1}.

EPC 9: Seja o alfabeto = {1,2,3}, e as palavras v = 12321 e w = 321123.

Determine:



a) |v|, |w|. b) v4, w2, w0 c) vw, wv d) vR, wR

e) *, + f) A linguagem ternária formada a partir do alfabeto .

EPC 10: Descreva informalmente ou formalmente as seguintes linguagens.

a) L = {0n1n | n > 1} b) L = {10n1n | n > 1 e n par}

c) Linguagem definida pelo conjunto dos inteiros positivos pares maiores que 0 e

menores que 18.

d) Linguagem definida pelo conjunto dos números racionais maiores que zero.

e) Linguagem que consiste em todas as palavras que começam com a e seguido por

zero ou mais símbolos b.

EPC 11: Seja A um autômato composto pelos seguintes elementos: um conjunto Q

de estados, um alfabeto , um conjunto de funções de transição do tipo : Q

Q, um estado inicial q0 Q, e um conjunto de estados aceitos F Q. Apresente

formalmente a 5-tupla que corresponde ao autômato A.



31. Definições, Teoremas e Provas

31.1. Conceitos Básicos

Definições, teoremas e provas são centrais para qualquer área matemática e para a

teoria da computação.

Definição: descreve os objetos e os conceitos usados. Deve ser simples, porém

precisa.

Após a definição de vários objetos e noções, geralmente são feitas afirmações

ou proposições matemáticas sobre eles. Normalmente uma afirmação atribui

propriedades a algum objeto.

Obs.: nem sempre uma afirmação é verdadeira.

Prova: é um argumento lógico e formal convincente de que uma afirmação é

verdadeira.

Teorema: é uma afirmação matemática verdadeira, ou seja, provadamente

verdadeira.



Normalmente um teorema é uma afirmação verdadeira de interesse particular.

Algumas vezes provamos que uma determinada afirmação é verdadeira, pois

isso facilita a prova de outra afirmação mais importante. A afirmação ou

proposição que facilita a prova de uma outra é conhecida como lema.

Algumas vezes também usamos um teorema ou sua prova para concluir

facilmente que outras proposições relacionadas também são verdadeiras. Estas

proposições são chamadas corolários.

31.2. Tipos de Provas Formais

A única forma de determinar se uma dada afirmação é verdadeira é com uma

prova matemática.

Em alguns casos uma afirmação possui múltiplas partes e todas precisam ser

provadas para que a prova fique completa.

Um exemplo típico é: P Q.

Neste caso, precisa ser provado que (SE) P Q e (SOMENTE SE) Q P.



Há vários tipos de provas possíveis. Dentre estas serão apresentadas brevemente 3:

Prova por construção;

Prova por contradição; e

Prova por indução.

Prova por construção: Um dado objeto existe se for possível mostrar como

construí-lo. Exemplo:

Seja um grafo k-regular aquele no qual cada nó tem grau k.

Teorema: Para cada número par n > 2, um grafo 3-regular com n nós.

Prova: Seja n um número par maior do que 2. Construa um grafo G = V,E

com n nós no qual o conjunto de nós de G é V = {0,1,...,n1}, e o conjunto de

arcos de G é:

E = {(i,i+1) | para 0 i n2} {(n1,0)} {(i,i+n/2) | para 0 i n/21}



Prova por contradição: Uma forma comum de provar um teorema é assumir que o

argumento é falso e mostrar que isso resulta em uma falácia. Exemplo:

Teorema: A 2 é um número irracional.

Prova por contradição: Vamos assumir que 2 seja um número racional. Então:

n

m2 , onde ambos, n e m, são inteiros.

Se m e n são divisíveis pelo mesmo inteiro maior que 1, então divida ambos por

este inteiro; o que não altera o valor da razão.



Agora n e m não podem ser par.

Algum algebrismo...

mn 2 ; 2n2 = m2 m é par e podemos escrever m = 2k, k Z.

Portanto, 2n2 = (2k)2 = 4k2 n2 = 2k2 e concluímos que n também é par.

Isso contradiz a hipótese de que ambos são ímpares e, portanto, provamos que 2

é irracional.

Prova por indução: Trata-se de um método avançado para mostrar que todos os

elementos de um conjunto infinito possuem a propriedade.

Exemplos: podemos usar uma prova por indução para mostrar que uma

expressão matemática computa um dado valor para toda especificação de suas

variáveis, ou para mostrar que um dado programa funciona corretamente em

todos os passos para todas as entradas.

Toda prova por indução consiste em duas partes: a) Uma base; e b) Um passo

indutivo.



Exemplo: Consideremos o problema de mostrar a corretude de uma fórmula

usada para calcular a prestação mensal de um financiamento imobiliário.

Seja: P o valor do financiamento; I a taxa de juros anual; Y o pagamento

mensal; e P(t) o valor restante da dívida. Vamos definir uma variável M,

denominada de multiplicador mensal, da seguinte forma: M = 1 + I/12.

A cada mês o valor do empréstimo aumenta devido aos juros e, ao mesmo

tempo, diminui devido aos pagamentos sendo efetuados: P(t+1) = P(t)M Y.

Teorema: Para cada t 0,

1

1)(

M

MYPMtP

tt

(1)

Prova:

Base: Provar que a fórmula é verdadeira para t = 0.

Em t = 0,



1

1)0(

00

M

MYPMP

P(0) = P.

Passo indutivo: Para todo k 0 mostrar que a Eq. (1) é verdadeira.

1

1)(

M

MYPMkP

kk

; (2)

Da definição temos que: P(k+1) = P(k)M Y. (3)

Substituindo a Eq. (3) na Eq. (2) e fazendo algum algebrismo derivamos a Eq. (1).

EPC 12: Assumindo que ao final de t meses você terá quitado seu financiamento,

use a Eq. (1) para encontrar uma expressão de cálculo da mensalidade de um

financiamento imobiliário com as seguintes características:

P = R$ 80.000,00

I = 12% ao ano

t = 120 meses (dez anos)



EPC 13: Compare o valor da prestação determinada pela sua expressão matemática

com uma simulação feita em dois bancos on-line (exemplos: CEF, BB, HSBC, Real,

Itaú, Nossa Caixa, Bradesco, etc.). Discuta eventuais diferenças nos valores.

EPC 14: Encontre o erro da seguinte prova.

Teorema: 2 = 1.

Prova: Considere a equação a = b e a seguinte sequência de operações:

a.a = b.a a2 = ab

a2 b2 = ab b2 (a b).(a + b) = b(a b) a + b = b.

Assim, se a = b =1, temos que 2 = 1!

EPC 15: Prove, usando grafos, que a seguinte afirmação é falsa: “Em qualquer festa

com 5 pessoas há necessariamente 3 que se conhecem mutuamente ou 3 que não se

conhecem mutuamente.”



32. Escalares, Vetores e Matrizes

32.1. Escalar

Uma variável que assume valores no eixo dos números reais é denominada

escalar. Os escalares são descritos por letras minúsculas do alfabeto romano

expressas em itálico, ou do alfabeto grego. O conjunto de todos os escalares reais

é representado por ou 1.

O módulo de um escalar real x é dado na forma:

0 se

0 se

xx

xxx

32.2. Vetor

Um arranjo ordenado de n escalares xi (i=1,2,...,n) é denominado vetor de

dimensão n. Os vetores são descritos por letras minúsculas do alfabeto romano

expressas em negrito e assumem a forma de vetores-coluna ou vetores-linha. Os

vetores geralmente são representados por vetores-coluna, na forma:



nx

x

x

2

1

x ou Tnxxx 21x .

O conjunto de todos os vetores de dimensão n com elementos reais é representado

por n. Diz-se então que x n.

Um escalar é um vetor de dimensão 1.

Vetor 0n: é o vetor nulo de dimensão n, com todos os elementos iguais a zero. O

subscrito n é suprimido quando não há margem à dúvida.

Vetor 1n: é o vetor de dimensão n com todos os elementos iguais a 1.

Vetor ei: é o vetor normal unitário de dimensão n (a dimensão deve ser indicada

pelo contexto) com todos os elementos iguais a 0, exceto o i-ésimo elemento que é

igual a 1. Neste caso, 1 i n.



32.3. Matriz

Um arranjo ordenado de m.n escalares xij (i=1,2,...,m; j=1,2,...,n) é denominado

matriz de dimensão mn. As matrizes são descritas por letras maiúsculas do

alfabeto romano expressas em itálico (ou apenas em negrito), e assumem a forma:

mnmm

n

n

xxx

xxx

xxx

21

22221

11211

X.

O conjunto de todas as matrizes mn com elementos reais é representado por

m n ou mn. Diz-se então que X mn.

As colunas da matriz X são vetores-coluna descritos por

mi

i

i

i

x

x

x

2

1

x , i=1,...,n.



As linhas da matriz X são vetores-linha descritos por jnjjj xxx 21)( x ,

j=1,...,m.

Um vetor é uma matriz com número unitário de linhas ou colunas.

32.4. Conceitos Adicionais para Matrizes

A transposta de uma matriz A, escrita AT, é a matriz obtida escrevendo as colunas

de A, em ordem, como linhas. Ou seja, se A = [aij] é uma matriz mn, então

AT = [bij] é a matriz nm onde bij = aji.

o O transposto de um vetor linha é um vetor coluna, e vice-versa.

Dada uma matriz A de dimensão nn, o cofator do elemento aij (i,j=1,2,...,n) é

dado na forma:

ijji

ij mc

1 ,

onde mij é o determinante da matriz formada eliminando-se a i-ésima linha e a j-

ésima coluna da matriz A.

Dada uma matriz A de dimensão nn, o determinante de A é dado na forma:



ica

jca

n

j ijij

n

i ijij

qualquer para ,

ou

qualquer para ,

det

1

1

AA

onde cij é o cofator do elemento aij.

Com isso, se B é uma matriz obtida a partir de A pela troca de duas de suas

colunas, então det(B) = det(A).

Dada uma matriz A de dimensão nn, a adjunta de A, representada por adj(A), é

dada na forma:

adj(A) = { ija }

onde ija = cji, o cofator do elemento aji.

São válidas as seguintes igualdades:

A

AA

AAA

AAA

det

adj

.det = .adj

.det = .adj1

I

I.

A inversa de uma matriz A nn é uma matriz M nn tal que



AM = MA = I.

A notação adotada para a matriz M é: M = A1.

Para que uma matriz seja inversível, ela tem que ser quadrada e não-singular.

Vale a seguinte propriedade: (A1)T = (AT)1.

Um operador linear é uma transformação que pode ser descrita por formas

matriciais, de modo que D X. Um operador linear, que mapeia vetores do n no

m, pode ser descrito por uma matriz A mn, tal que

y = Ax, x n e y m.

33. Operações Elementares entre Vetores e Matrizes

Dados dois vetores x, y m, x = [x1, x2,..., xm]T e y = [y1, y2,..., ym]T, a adição e

subtração (Figura 6) deles é feita como a seguir:

Adição Vetorial: x + y = [x1+y1, x2+y2,..., xm+ym]T.

Subtração Vetorial: x y = [x1y1, x2y2,..., xmym]T.



x

y x + y

x

y

x y

(a) (b)

Figura 6: Adição vetorial (a) e subtração vetorial (b).

A multiplicação de um vetor x m por um escalar a é feita da seguinte

forma:

Multiplicação por um escalar: a.x = [a.x1, a.x2,..., a.xm]T.

Uma matriz A mn pode ser multiplicada por uma outra matriz B rl se, e

somente se, n = r; e o resultado é uma matriz C ml.



Dadas:

mnmm

n

n

aaa

aaa

aaa

21

22221

11211

A,

rlrr

l

l

bbb

bbb

bbb

21

22221

11211

B,

Cada elemento cij da matriz C ml, C = A.B, é obtido como a seguir:

.,...,1;,...,1,1

ljmibacn

k

kjikij

A multiplicação de uma matriz A mn por um escalar b é feita

simplesmente multiplicando cada elemento da matriz A pelo escalar, de maneira

similar à multiplicação de um vetor por um escalar.

Da mesma forma, a soma ou subtração de duas matrizes pressupõe que elas sejam

de mesma dimensão e é feita somando-se ou subtraindo-se elemento a elemento

das matrizes.



34. Espaço Vetorial Linear

Um campo é uma estrutura algébrica na qual as operações de adição, subtração,

multiplicação e divisão (exceto divisão por zero) podem ser feitas, e onde também

valem as regras da associatividade, comutatividade e distributividade.

Os campos são objetos importantes de estudo, pois eles fornecem uma

generalização apropriada dos domínios dos números, como os conjuntos dos

números racionais, conjunto dos números reais e conjunto dos números

complexos.

O espaço vetorial é a estrutura básica da álgebra linear.

A definição de um espaço vetorial V, cujos elementos são denominados vetores,

envolve um campo arbitrário F, cujos elementos são denominados escalares.

Ao considerarmos vetores, suas operações (p. ex., adição e multiplicação por

escalar) e algumas de suas propriedades, chegamos a uma descrição de uma

estrutura matemática denominada espaço vetorial.



Um espaço vetorial X, associado a um campo F, consiste em um conjunto de

elementos (vetores) sobre os quais estão definidas 2 operações:

1. Adição (X X X): (x + y) X, x, y X;

2. Multiplicação por escalar (F X X): (x) X, x X e F.

34.1. Axiomas (Propriedades Vetoriais)

x + y = y + x (propriedade comutativa)

)()(

)()(

xx

zyxzyx

(propriedade associativa)

)(

)(

xxx

yxyx

(propriedade distributiva)

x + 0 = x (vetor nulo)

1x = x (elemento neutro)



34.2. Propriedades Adicionais

0x = 0

0 = 0

x + y = x + z y = z

x = y, 0 x = y

x = x, x 0 =

)(

)(

xxx

yxyx

(propriedade distributiva)

34.3. Subespaço Vetorial Linear

Um subespaço vetorial é um espaço vetorial “menor” dentro de um espaço

vetorial “maior”. Por exemplo, uma reta w que passa pela origem do espaço

vetorial V = 2 é um subespaço de V.

Um subconjunto não-vazio S de um espaço vetorial linear X é um subespaço de X

se S yx sempre que x e y S.



Dito de outra forma, seja (X,F) um espaço vetorial linear e S um subconjunto de X.

Diz-se então que (S,F) é um subespaço vetorial de (X,F) se S forma um espaço

vetorial sobre F através das mesmas operações definidas sobre (X,F).

Exemplos: 1. S {0}

2. S n é subespaço de X n

Se M e N são subespaços de X, então M N também é um subespaço de X.

Todo espaço é um subespaço de si mesmo.

34.4. Combinação Linear e Combinação Convexa

Seja S = {x1, x2, ..., xn} um conjunto de vetores de um espaço vetorial linear (X,).

O vetor v V é dito uma combinação linear de x1, x2, ..., xn se

v = nnaaa xxx 2211 ,

onde a1, a2, ..., an .



A combinação linear de vetores permite a obtenção de novos vetores a partir de

vetores dados.

Se os escalares a1, a2, ..., an são tais que ai 0 (i=1,2,...,n) e 11

n

i ia , então

a combinação linear é chamada combinação convexa dos elementos

x1, x2, ..., xn X.

Obs.: Genericamente, expressar um vetor v Fn como uma combinação linear

dos vetores u1, u2,..., um, ui Fn, i = 1,...,m, é equivalente a resolver um sistema de

equações lineares Ax = b, onde v é o vetor coluna b de constantes, e ui, i = 1,...,m,

são os vetores coluna da matriz de coeficientes A.

34.5. Dependência Linear de um Espaço Vetorial

Considere {x1, x2, ..., xn} um conjunto de vetores pertencentes a X. O conjunto

S [x1, x2, ..., xn], chamado subespaço gerado pelos vetores {x1, x2, ..., xn},

consiste de todos os vetores em X escritos como combinação linear de vetores em

{x1, x2, ..., xn}. Neste caso, S é um subespaço vetorial de X.



Um conjunto de vetores {x1, x2, ..., xn} é dito linearmente independente se e

somente se 01

n

iiia x implica ai = 0, i=1,...,n.

o Caso contrário eles são ditos linearmente dependentes.

Um conjunto de vetores linearmente independentes {x1, x2, ..., xn} forma uma base

para X se X [x1, x2, ..., xn].

Neste caso, diz-se que X tem dimensão n. Se n é finito, então X é um espaço

vetorial de dimensão finita.

O posto de uma matriz A mn é dado pelo número de colunas (ou linhas) LI, de

modo que posto(A) min(m,n).

Se posto(A) = min(m,n), então diz-se que a matriz tem posto completo.

35. Produto Interno

Considere x,y X e . O produto interno x,y é um número real que

satisfaz:



o x,y = y,x

o x+y,z = x,z + y,z

o x,y = x,y

o x,x 0 x X, e x,x = 0 x = 0

Para X n e x,y X, tem-se que x = [x1, x2, ..., xn]T e y = [y1, y2, ..., yn]

T, e o

produto interno assume a forma:

yxyxT

n

iii yx

1

,

36. Produto Externo

O produto externo entre dois vetores x n e y m é uma matriz de dimensão

n m de posto unitário. Sendo x = [x1, x2, ..., xn]T e y = [y1, y2, ..., ym]T, o produto

externo assume a forma:



mnn

m

T

yxyx

yxyx

yxyxyx

1

2212

12111

xy

Em contraste com o caso do produto interno, os vetores x e y podem ter dimensões

distintas.

Mesmo quando as dimensões são as mesmas, ou seja, n = m, a matriz quadrada

resultante pode não ser simétrica.

37. Números e Espaços Complexos

O conjunto dos números complexos é denotado por .

Formalmente, um número complexo é um par ordenado (a,b) de números reais

onde a igualdade, a adição e a multiplicação são definidas como a seguir:

o (a,b) = (c,d) se e somente se a = c e b = d;

o (a,b) + (c,d) = (a+c,b+d);



o (a,b) . (c,d) = (acbd, ad+bc).

O número real a pode ser identificado com o número complexo (a,0), enquanto o

número complexo (0,1) é representado por i.

O número i tem a seguinte propriedade:

i2 = ii = (0,1).(0,1) = (1,0) = 1 ou i = 1 .

Portanto, qualquer número complexo z = (a,b) pode ser escrito como

z = (a,b) = (a,0) + (0,b) = (a,0) + (b,0).(0,1) = a + bi.

A notação acima z = a + bi, onde a Re(z) e b Im(z) são chamados de parte real

e imaginária de z, respectivamente, é mais conveniente do que a representação

z = (a,b).

37.1. Complexo Conjugado e Valor Absoluto

Seja z = a + bi um número complexo. O conjugado de z, z* ou z , é definido

como:



biabia zz*

O valor absoluto de z, |z|, é definido como sendo a raiz quadrada não-negativa de

zz*, e é igual a norma do vetor (a,b) 2:

|z|22 ba zz .

37.2. Plano Complexo

Analogamente ao caso dos números reais que podem ser representados por pontos

em uma linha, os números complexos em podem ser representados por pontos

em um plano (Figura 7).



|z|

|z|cos

z = a+bi

|z|sin

Im(z)

b

a Re(z)

Figura 7: Plano complexo.

37.3. Coordenadas Polares

Também é possível expressar números complexos em termos de coordenadas

polares, como um par ordenado (|z|,), onde |z| é o valor absoluto de z e é o

ângulo relativo ao eixo real positivo.

A conversão de coordenadas retangulares para polares é feita como a seguir:

|z| = 22 ba , = tan1(b/a).

A conversão de coordenadas polares para retangulares é feita como a seguir:



a = |z|cos, b = |z|sin.

37.4. Vetores em n

O espaço complexo, n, é o conjunto de todas as n-tuplas de números complexos.

Os elementos de n são chamados de pontos ou vetores.

37.5. Produto Interno em n

Sejam u = [u1,…, un] e v = [v1,…, vn] dois vetores em n. O produto interno entre u

e v é definido por

.*,

1

n

i

iivuvuu.v

A função n n é um produto interno se ela satisfaz:

o , é linear no segundo argumento

o u,v = v,u*

o u,u 0, com igualdade apenas se u = 0.



37.6. Matrizes Complexas

Uma matriz complexa é uma matriz com entradas (elementos) complexas.

O conjugado, A*, de uma matriz complexa A é obtido tomando-se o conjugado de

cada entrada da matriz A:

Se A = [aij], então A* = [bij], onde bij = aij*.

37.7. Matrizes Complexas Especiais: Auto-Adjunta (Hermitiana), Unitária

Uma matriz A pra a qual

A† = (A*)T = A

onde o conjugado transposto é representado por A†, AT é o transposto, e A* é o

complexo conjugado, é dita auto-adjunta.

Se uma matriz é auto-adjunta ela é dita Hermitiana, o que equivale a dizer que

aij = aji*.

Uma matriz complexa A é unitária se A†A

1 = A1A

† = I, ou seja, A† = A1.

o Em outras palavras, uma matriz unitária satisfaz a condição A†A = AA

† = I.



o Uma matriz complexa é unitária se e somente se suas linhas (colunas) formam

um conjunto ortonormal em relação ao produto interno dos vetores complexos.

Há vários exemplos de matrizes Hermitianas relevantes ao estudo de computação

quântica, em particular as Matrizes de Pauli:

0 = I =

10

01

1 = X =

01

10

2 = Y =

0

0

i

i

3 = Z =

10

01

37.8. Espaços de Hilbert

Um espaço de Hilbert H de dimensão finita é um espaço vetorial completo sobre

os números complexos equipado com um produto interno:

H H , (x,y) x,y.

Um espaço vetorial H é dito completo se para cada sequência de vetores xi tal que

limm,n ||xm x|| = 0,



existe um vetor x H tal que:

limn ||xn x|| = 0.

37.9. Produto Tensor

O produto tensor, também denominado de produto de Kronecker, pode ser

aplicado a matrizes, vetores e espaços vetoriais em diferentes contextos.

No caso particular que precisamos neste curso, o produto tensor corresponde a

uma forma de unir espaços vetoriais no intuito de formar espaços vetoriais

‘maiores’ em sistemas quânticos.

O produto tensor entre duas matrizes A de dimensão r s e B de dimensão t u é

denotado por A B:



BBB

BBB

BBB

BA

rsrr

s

aaa

aaa

aaa

21

212221

11211

e possui dimensão rt su.

38. Transformações Afins

Uma transformação w : 2 2 da forma

w(x1,x2) = (ax1 + bx2 +e, cx1 + dx2 + f),

onde a, b, c, d, e, f são números reais é denominada de uma transformação

bidimensional afim, ou simplesmente transformação afim.

Também é possível empregar uma notação matricial equivalente para uma

transformação afim:

tAxx

f

e

x

x

dc

ba

x

xww

2

1

2

1)(

,



onde

dc

baA e

f

et .

As principais transformações afins são:

Translação:

fx

ex

f

e

x

x

2

1

2

1

.

Escalonamento:

22

11

2

1

2

1

0

0

xs

xs

x

x

s

s

.

Reflexão:

2

1

2

1

10

01

x

x

x

x

.

Rotação:

1

2

2

1

01

10

x

x

x

x

.



Translação

Escalona-mento

Reflexão

Rotação

Figura 8: Representação geométrica das transformações afins.



Note que uma transformação afim, w(x) = Ax + t, pode combinar mais de uma

destas operações, ou seja, uma ‘imagem’ pode ser rotacionada, escalonada,

transladada e refletida ao mesmo tempo.

39. Distribuição de Probabilidade

Uma variável aleatória é uma variável, geralmente representada por x, que

assume um único valor numérico para cada resultado de um experimento.

Esta variável pode corresponder a qualquer item do sistema, por exemplo, seu

estado.

A palavra aleatória indica que, geralmente, apenas conhecemos o valor da variável

após a execução do experimento.

o Assim, para cada valor possível da variável há uma probabilidade de ocorrência

associada.



Um sistema probabilístico é aquele no qual não sabemos exatamente o estado do

sistema (valor da variável), mas conhecemos a distribuição de probabilidade dos

estados do sistema.

Em outras palavras, sabemos que o sistema está nos estados x1, x2, ..., xn, com

probabilidades p1, p2, ..., pn, que somam no total 1.

o Se tivéssemos um contínuo de estados possíveis, deveríamos ter uma

distribuição de probabilidades cuja integral é 1.

Notação:

p1x1 + p2x2 + ... + pnxn

onde pi ≥ 0 e

n

i

ip1

1 corresponde a uma distribuição de probabilidades.

Isso significa que o sistema está em um estado xi com probabilidade pi.

2015: fundamentos teóricos da computação

Technology

contedo fundamentos

computao natural lcon

by leandro nunes de

automata theory

and computation

definio formal

conjuntos de slides

disciplina teoria