1. Indecibilidade
Yuri Tavares dos Passos

2. Tudo é inteiro
●
Tipos de dados são ferramentas
importantes em programação
●
Mas em um nível mais baixo, existe
apenas um tipo: inteiro e cadeias de
inteiros (strings).
●
Strings que representam programas são
apenas outra forma de pensar sobre o
mesmo tipo de dado.

3. Exemplo: Texto
●
Cadeias ASCII ou Unicode podem ser
pensadas como cadeias binárias com
cada caractere composto por 8 ou 16 bits.
●
Cadeias binárias podem ser pensadas
como um inteiro.
●
É possível imaginar “a i-ésima cadeia (ou
string)”, ordenando-as a depender de seu
valor.

4. Cadeias binárias para
inteiros
●
101, 0101, 00101, … são todas representações
da “quinta cadeia”
●
Mas se fossemos representar 101 como uma
string diferente de 0101, então poderíamos
ordenar ambas prefixando um 1 imaginário em
cada uma delas
– 101 seria a 13ª string
– 0101 seria a 21ª string
– 00101 seria a 37ª string

5. Exemplo: Imagens
●
Representar uma imagem, p.e. GIF
●
O PGM é uma cadeia ASCII
●
Converte-se esta cadeia para binário
●
Converte-se binário para inteiro
●
Agora temos a noção de “i-ésima imagem”

6. Exemplo: Provas
●
Uma prova formal é uma sequência
expressões lógicas, cada uma segue da
anterior
●
Codifique expressões matemáticas como
uma string Unicode.
●
Converta em seguida para string binária e
depois inteiro.

7. Exemplo: Provas
●
Mas uma prova é uma sequência de
expressões, logo é necessário separá-las.
●
Também, precisamos indicar quais
expressões são fornecidas.

8. Exemplo: Provas
●
Uma forma rápida de introduzir novos
símbolos em strings binárias:
– Dada uma string binária, preceda cada bit por
um 0.
●
101 torna-se 010001
– Use cadeias binárias de dois ou mais 1's como
símbolos especiais.
●
Exemplo: 111 = “A seguinte expressão é dada”; 11 =
“fim de expressão”

9. Exemplo: Provas
A seguinte
expressão
é dada
Expressão
Note que este 1
poderia ser parte
do “fim de expr.”
Fim de
expressão
A seguinte
expressão
é dada
Expressão
Fim de
expressão

10. Exemplo: Programas
●
Programas também são exemplos de um
tipo de dado.
●
Um programa é um arquivo ASCII, basta
fazer o mesmo que foi feito para cadeias.
●
Portanto, faz sentido pensar no “i-ésimo
programa”
●
Será que existem tantos programas?

11. Exemplo: MT
●
Uma MT também pode ser codificada
como uma string
● Seja M = (Q, {0,1}, Γ, δ, q1, B, F).
●
Para isto deve-se atribuir um número
inteiro para cada um dos estados de Q.

12. Exemplo: MT
● Considere X1, X2, …, Xs, os símbolos de Γ.
Podemos convencionar que X1 = 0, X2 = 1,
X3 = B e os inteiros restantes são os
demais símbolos.
● Os sentidos E e D serão D1 e D2.

13. Exemplo: MT
● Uma função de transição δ(qi,Xj) =
(qk,Xl,Dm) será codificada como
0i10j10k10l10m.
●
Considerando que Ci é o código de
alguma transição de M, M será codificado
como:
– C111C211C311...Cn-111Cn

14. Exemplo: MT
●
Considere a MT
– M = ({q1,q2,q3}, {0,1}, {0,1,B}, δ, q1, B, {q2} )
– δ(q1,1) = (q3,0,R)
– δ(q3,0) = (q1,1,R)
– δ(q3,1) = (q2,0,R)
– δ(q3,B) = (q3,1,L)

15. Exemplo: MT
●
Os códigos para cada regra são:
– 0100100010100
– 0001010100100
– 00010010010100
– 0001000100010010
●
Um código para M é:
– 010010001010011000101010010011000100100101001
10001000100010010
●
Na verdade são 4! = 24 códigos possíveis.

16. Linguagens de uma MT
●
A MT possui duas definições de
linguagens, por estado final e por parada.
●
Considere DI, a descrição instântanea e ⊦*
o resultado de vários movimentos de uma
MT.

17. Linguagens de uma MT
●
Por aceitação por estado final:
– L(M) = {w | q0w ⊦* I, onde I é uma DI contendo
um estado final}.
●
Por parada (trava):
– H(M) = {w | q0w ⊦* I e não há movimentos
possíveis a partir de I}.

18. Equivalência entre aceitação
por estado final e parada
1)Se L = L(M), então existe uma TM M' tal
que L = H(M')
2)Se L = H(M), então existe uma TM M'' tal
que L = L(M'')

19. Prova de 1: Aceitação
→Parada
●
Modifique M para tornar-se M' como segue
– Evite que M' acidentalmente trave.
●
Introduza um novo estado s, que roda para direita
para sempre, isto é, X∀ ∈Γ, δ(s, X) = (s, X, R).
●
Se q não é de aceitação e δ(q, X) é indefinido, faça
δ(q, X) = (s, X, R).

20. Prova de 2:
Parada→Aceitação
●
Modifique M para tornar-se M'' como
segue:
– Introduza um novo estado f, o único estado de
aceitação de M''.
– f não possui movimentos
– Se δ(q, X) é indefinido para algum estado q e
símbolo X, defina δ(q, X) = (f, X, R).

21. Linguagens Recursivamente
Enumeráveis
●
Agora vemos que a classe das linguagens
das MT que aceitam por parada ou por
aceitação é a mesma.
●
Esta classe é conhecida como Linguagens
Recursivamente Enumeráveis

22. Linguagens Recursivamente
Enumeráveis
●
Recursivamente: Vem de modelos
computacionais anteriores as MT, que
representam funções computáveis.
●
Enumerável: Significa que os elementos
pertencentes a esta linguagem podem ser
enumerados por uma MT em alguma ordem.
– Contudo, os elementos que não pertençam a ela
podem fazer a MT rodar para sempre sem parar.

23. Linguagens Recursivamente
Enumeráveis
●
Enumerador
– Máquina de Turing com “impressora”

24. Linguagem recursiva
●
Uma linguagem L é recursiva se L = L(M) e
M pára para qualquer string de entrada w.
●
Se um problema é representado pela
linguagem L e L é recursiva, então
dizemos que este problema é decidível.
●
Caso contrário, este problema é
indecidível.

25. Linguagem recursiva
●
Dado um problema, um algoritmo é uma MT que
garante a parada se aceita ou não uma string.
●
A classe das linguagens recursivas está contida
na classe das linguagens recursivamente
enumeráveis (RE).
– Por definição, LRE são linguagens aceitas por alguma
MT.
●
Uma linguagem que não possui MT é dita não
recursivamente enumerável (não-RE).

26. Relação entre linguagens
recursivas e RE

27. Quantidade de linguagens
●
As linguagens existentes em {0,1}* são contáveis?
– Ou seja, é possível ordená-las?
●
Não. Prova:
●
Suponha que nós possamos enumerá-las e
tomamos a “i-ésima linguagem”
●
Considere a linguagem L = {w | w é a i-ésima
string binária e w não pertence a i-ésima
linguagem}

28. Quantidade de linguagens
●
Veja que L é uma linguagem dentro de
{0,1}*
●
Portanto, L é a j-ésima linguagem para
algum j particular.
– Relembrando: L = {w | w é a i-ésima string
binária e w não pertence a i-ésima linguagem}
●
Seja x a j-ésima string.

29. Quantidade de linguagens
●
x ∈ L?
– Se sim, temos:
●
x ∈ {w | w é a i-ésima string binária e w não pertence
a i-ésima linguagem}
● x ∉ L=Lj pela definição de L
– Se não, temos:
●
x ∉ {w | w é a i-ésima string binária e w não pertence
a i-ésima linguagem}
● então x ∈ L=Lj pela definição de L

30. Strings
1 2 3 4 5 …
1
12
3
4
5
…
Linguagens
0
111
1
0
00 …
…
Diagonalização

31. Strings
1 2 3 4 5 …
1
02
3
4
5
…
Linguagens
1
110
0
1
00 …
…
Inverta cada
uma das
entradas
A diagonal
invertida
não pode ser
uma linha,
pois no
minímo uma
delas está em
desacordo.
Diagonalização

32. Quantidade de linguagens
●
Nós temos uma contradição: x está fora de
L assim como ele pertence a L. Logo,
nossa suposição de que era possível
enumerá-las está errada.
●
Isto leva a conclusão de que existem mais
linguagens do que programas.
●
Existem linguagens sem algoritmo que as
aceite.

33. Linguagem da
diagonalização
●
Considere o seguinte problema: Considere
uma MT M e uma entrada w para esta MT.
Existe alguma MT que não aceita ela
mesma como entrada w.
– Ou seja, w é M em codificação binária.
●
Para descobrir a solução deste problema,
podemos pensar se existe uma MT que
enumere todas estas MT.

34. Tabela de aceitação
1
2
3
4
5
6
.
.
.
TM
i
1 2 3 4 5 6 . . .
x
x = 0 se a i-ésima
MT não aceita a
j-ésima string;
x = 1 indica que
aceita
String j

35. Linguagem da
diagonalização
●
Transformando este problema em uma
linguagem, vemos uma semelhança com a
o discutido anteriormente.
●
A linguagem descrita anteriormente é
conhecida como linguagem da
diagonalização (Ld)

36. Linguagem da
diagonalização
● Considere wi é a i-ésima string binária e Mi
é a i-ésima MT representada por uma
cadeia binária.
● Ld= {wi | wi = Mi e Mi não aceita wi}
●
Como mostramos que não é possível
enumerar uma linguagem como tal, então
não há uma MT que a enumere.

37. Linguagem da
diagonalização
● Teorema: Ld não é RE.
●
Prova:
– Suponha que Ld seja L(M) para alguma MT M.
– Existe algum código de M = Mi. Considere wi =
Mi.

38. Linguagem da
diagonalização
●
Prova (continuação):
– Perguntamos: wi∈L(Mi)?
● Se wi∈L(Mi) então Mi aceita wi. Mas, por definição
de Ld, não deveria aceitar.
● Se wi∉L(Mi) então Mi não aceita wi. Mas, por
definição de Ld, Mi deveria aceitar wi.
– Contradição! Logo não é RE.

39. Referência
●
[1] HOPCROFT, John E.; ULLMAN, Jeffrey D.;
MOTWANI, Rajeev. Introdução à teoria de
autômatos, linguagens e computação. [Rio de
Janeiro]: Campus, c2003. p. 328-352
●
[2] SIPSER, Michael. Introdução à teoria da
computação. 2.ed. São Paulo, SP: Cengage
Learning, c2007. xxi, 459 p. ISBN 9788522104994
●
Traduzido e adaptado dos slides de Jeffrey D.
Ullman.