2014.

a. M = “Sobre a entrada x, onde x é uma cadeia:

1) Faça uma varredura na fita e marque o primeiro 0 não marcado. Se não
encontrar nenhum, vá para o estágio 5.
2) Continue a varredura na fita e marque o primeiro 0 não marcado. Se não
encontrar nenhum, rejeite. Caso contrário, mova a cabeça da fita para a
frente da fita.
3) Faça uma varredura na fita e marque o primeiro 1 não marcado. Se não
encontrar nenhum, rejeite.
4) Mova a cabeça da fita para a frente da fita e vá para o estágio 1.
5) Mova a cabeça da fita para a frente da fita. Faça uma varredura na fita e
procure por algum 1 não marcado. Se encontrar, rejeite. Se não, aceite”

b. M = “Sobre a entrada x, onde x é uma cadeia:

1) Vá até a extremidade direita da fita.
2) Faça uma varredura da direita para a esquerda até encontrar a primeira
ocorrência de 1.
3) Faça uma varredura a partir do bit anterior ao 1 até a ocorrência do #,
trocando os bits por onde a cabeça passar.” //complemento a dois
4) Na primeira fita, copie a cadeia depois do # para a segunda fita.
5) Apague o conteúdo a partir do # da primeira fita.
6) Repita até que a segunda fita contenha apenas zeros:
a) Subtraia 1 da segunda fita, somando 1 na primeira. Para somar,
faça uma varredura da direita para a esquerda, trocando os 1’s por
 0’s até a primeira ocorrência de 0; troque o 0 por 1. Se não existir
0’s, desloque o conteúdo da fita para a direita, e escreva zero na
primeira posição. Para subtrair, faça uma varredura da direita para
a esquerda trocando os bits (complemento de um); some 1 à
cadeia; faça o complemento de um novamente.
7) Apague o conteúdo da segunda fita.”

Por GH:
Vou dar a ideia da resolução. Usa uma MT de 3 fitas, na primeira ia ficar o resultado, na
segunda o primeiro número e, na terceira o segundo número; tem que colocar um
passo como "Copie a cadeia antes do # para a segunda fita e copie a cadeia depois do
# para a terceira fita. Apague o conteúdo da primeira fita". Depois faz um loop pra ficar
fazendo umas varreduras da direita pra esquerda e fazendo a subtração bit a bit e
colocando o resultado na primeira fita. Na hora eu avisei que era pra usar complemento
de 2, então tem que tomar cuidado com umas negações que talvez precisem ser feitas
em alguns bits. No final, apaga as cadeias na segunda e da terceira fita.

dam4:

No caso não poderia usar uma subrotina para pegar o número binário e representar ele
por 1’s na fita não? Exemplo: 010 (2) ficaria 11 na fita, 011 (3) ficaria 111 na fita.
Colocava o cabeçote no final e iria voltando na esquerda procurando por um 1 então
trocaria 1 por 0, e voltaria a cabeça pro inicio, trocando o primeiro 1 que achasse por 0
também, ai ia para o lado direito de novo e repetiria até acabar o número de 1’s, depois
apagaria os 0’s da fita (no caso quando o cabeçote do lado direito achasse o hashtag
teria acabado). Ex: (pulando uns passos)
3 - 2 seria

111 # 11
111 # 10
110 # 10
110 # 00
100 # 00 (terminou porque achou o # então nenhum 1 resta do lado direito, agora
apagaria os 0’s ou uma alternativa era do começo fazer uma varredura e adicionar
cada 1 na fita principal e fazer a subrotina para transformar em binário novamente)
1 b b b b b b…

E como seria a subrotina? Se não precisar declarar eu fico feliz.

!
(=>) Se L é uma linguagem decidível, então existe um enumerador E que a enumera
em orgem lexicógrafica.
Seja D um decisor para L.
E = “Ignore a entrada:
1) Gere cada cadeia si de Sigma* em ordem lexicográfica.
1.1) Rode D sobre si. Se D aceitar, imprima si“
(<=) Se existe um enumerador E que enumera L em ordem lexicográfica, então L é
decidível.
D = “Sobre a entrada w:
1) Para cada s gerado por E, compare s com w. Se s = w, aceite. Se s > w,
rejeite. Se não, continue para a próxima s.”

Por GH:

Nesse daí a entrada é uma fórmula phi e um inteiro n, dizendo o tamanho máximo da
prova. Aí é só fazer um loop que ia gerando as cadeias que de tamanho entre 1 até n,
verificando se elas correspondiam a codificação de uma prova e, então verificando
cada proposição (i+1) decorria da proposição i pelas regras de dedução natural:
implicação, and, or, not, raa; se a última proposição fosse igual a phi, a máquina
aceitava. Se tivesse testado todas as provas de tamanho até n e nenhuma satisfizesse
as condições, rejeita. Mais ou menos assim:

D = "Sobre a entrada <phi, n>:

1. Para cada cadeia que corresponde a codificação de uma prova de tamanho 1 até n
(inclusive):
1.1 Para cada proposição na prova, a partir da segunda:
1.1.1 Verifique se ela segue da anterior pelas regras de dedução natural. Se
não, rejeite.
1.2 Se a última proposição for igual a phi, aceite.
2. Rejeite"

!
M = na entrada <G, L>
1) Para cada cadeia s de L:
1.1) Construir uma GLC B, onde L(B) = L(G) interseção (E*sE*)
1.2) Rode o decisor de Vglc sobre <B>. Se rejeitar, aceite.
2) Rejeite.

Como L é finita, ela também é regular, logo, L(B) sempre será uma linguagem livre de
contexto.

Questão 4.26 que é parecida:

Por GH:

Outra forma de fazer é usar o fato de que, se uma linguagem A é regular e B é livre-do-
contexto, então AnB é livre-do-contexto.(exercício 2.18 (a)).

Daí, dados a GLC G e a cadeia x, podemos construir um AFD que reconhece {0, 1}*x{0,
1}*, i.e., todas as cadeias que tem x como subcadeia, pegar a intersecção dessa
linguagem com a linguagem da gramática e testar se dá vazia:

D = "Sobre a entrada <G, x>:

1. Construa um AFD P_x de forma que L(P_x) = {0, 1}*x{0, 1}* e construa
uma GLC T de forma que L(T) = L(P_x)nL(G).
 2. Rode o decisor R de V_GLC sobre a entrada <T>, se ele rejeitar,
aceite; senão, rejeite."

2012.2

a. Seja A um decisor para Vafd.

A = “Sobre a entada <A>, onde A é um AFD:
1) Marque o estado inicial de A.
2) Repita até que nenhum novo estado venha a ser marcado:
2.2) Marque qualquer estado que tenha uma transição chegando nele a
partir de qualquer estado que já está marcado.
3) Se nenhum estado de aceitação estiver marcado, aceite. Caso contrário,
rejeite.”

Seja Da um decisor para A.

Da = “Sobre a entrada <G>, onde G é um grafo:
1) Selecione o primeiro nó de G e marque-o.
2) Repita o seguinte estágio até que nenhum novo nó seja marcado:
2.1) Para cada nó de G, marque-o, se ele estiver ligado por uma aresta a um nó
que já esteja marcado.
3) Faça uma varredura em todos os nós de G para determinar se eles estão todos
marcados. Se estiverem, aceite. Se não, rejeite.”

---------------------------------------------------------------------------------
b. Seja Dr um decisor para R.
Dr = “Sobre a entrada <B>, onde B é um AFD:
1) Contrua um AFD Br | L(Br) = L(B)^R.
2) Rode o decisor de EQafd sobre <B, Br> e aceite se ele aceitar. Se não,
rejeite.”
!
branco = b

q00101
bq1101
b1q201
bq3111
q3b111
bq0111
bbq511
bbbq51 ←----- aqui duhan e lucas
bbbbq5b ←----- como veio pra isso ? (luquitas - tipo, no final da fita, dps da entrada,
tem espaço em branco. a gente só botou o ‘b’ no final pra indicar esse espaço em
branco. mas no papel eu botei em todos o b no final já)
marlon: ah é porra, só me lgiuei agora q b é branco
bbbbbq6

MP 4 2010. v2

1. (4.0) Para cada um dos enunciados abaixo, diga se é Verdadeiro ou Falso.

(Warning: Uma resposta errada anula uma resposta correta!)

(rfm3) Respostas: VVFV

(i) O problema de se determinar, dado um AFD A, se L(A) contém alguma cadeia que
começa
com 0 e termina com 1 é decidível.

(i) M = “Sobre a entrada <A> onde A é um AFD:

1. Seja q0 o estado inicial de A. Seja q1 o estado delta(q0, 0) (o estado que sai de
q0 após receber um 0).
2. Faça uma busca em largura pelo autômato partindo do estado q1.
3. Para todo estado q alcançável a partir de q1, verifique se delta(q, 1) é um estado
de aceitação. Se existir um q tal que isso aconteça, aceite. Caso contrário, rejeite.

M decide o problema. Logo a resposta é VERDADEIRO.

(ii) Se existe uma MT para decidir a linguagem L, então existe uma MT para decidir o
complemento de L.

(ii) Trivialmente a resposta é VERDADEIRO.

Seja M uma MT que decide L. M aceita w se w pertence a L e rejeita caso
contrário.
Seja M’ uma MT que executa o seguinte algoritmo:
1) Rode M sobre w
2) Se M aceita w, rejeite w. Caso contrário, aceite.
M’ decide L, logo a resposta é verdadeiro.
(Linguagens decidíveis são fechadas sobre o complemento. Reconhecíveis não o são)

(iii) O problema de se determinar, dados uma MT M, uma cadeia w, e um estado q de

M, se
quanto M roda com w como entrada, M passa pelo estado q é decidível.

(iii) Suponha que exista uma MT M que decida esse problema. Rode M considerando
que q seja o estado de aceitação da outra MT. Note então que M decide se a outra MT
para ou não. Logo M decide o problema da parada. Como o problema da parada não é
decidível, então M não pode existir. Portanto a resposta é FALSO.

(iv) Se uma MT é reconhecível e não-decídivel, o seu complemento é irreconhecível.

(iv) MT M ntraé reconhecível e não é decidível. Suponha que exista M’ que reconheça o
complemento de M. Construa a seguinte M’’:
1) Rode, alternadamente, M e M’ para a eda w.
2) Se M aceitar w, aceite. Se M’ aceitar w, rejeite.
Note que uma das MTs deve aceitar w. Logo esse procedimento sempre acaba.
Portanto M’’ decide a linguagem. Mas a linguagem, por hipótese, era não-decidível.
Logo não existe M’ que reconheça o complemento de M. Logo o complemento de M é
irreconhecível.
Logo é VERDADEIRO.

2. (3.0) Enuncie claramente o Problema da Parada (Max. 3 linhas).

(rfm3) Dado uma descrição de um programa e uma entrada finita, decida se o

programa termina de rodar ou rodará indefinidamente, dada essa entrada.

3. (3.0) Seja Σ = {0,1}. Mostre que o problema de se determinar se uma GLC gera
alguma
cadeia em 1* é decidível. Em outras palavras, mostre que
{<G>| G é uma GLC sobre {0,1} e 1* ∩ L(G) ≠ ϕ }
é uma linguagem decidível.

(rfm3) Seja M uma MT:

M = Sobre uma entrada <G> faça:
1) Sejam Q e S conjuntos inicialmente vazios. Adicione as regras S0 -> … no
conjunto Q.
2) Tome um elemento r de Q. Remova r de Q e adicione-o em S.
3) Se r é do formato V -> 1..., aceite.
4) Se r é do formato V -> V’... (V’ é uma variável), adicione todas as regras V’ -> …
que não estejam em S à Q.
5) Se Q não está vazio, retorne ao passo 2. Caso contrário, rejeite.

M basicamete faz uma busca em largura sobre as regras de G, verificando se existe

alguma que possa ser a primeira substituição e que comece com 1. Se isso acontece
então M aceita. Se todas as regras foram processadas e M ainda não aceitou w, então
rejeite-a.

M então decide o problema. Logo existe uma MT decisora para tal linguagem, portanto
o problema é decidível.
MP 2011.1
____
01(4.0). Seja A uma MT e L(A) uma LTD(Linguagem Turing Decidível), prove que L(A)
também é LTD.

1. M = “Sobre a entrada <A, w>, onde A eh uma MT decidível e w uma cadeia:

1. Rode A com a entrada w
2. Se A aceitar, rejeite
3. Se A rejeitar, aceite”

02(3.0). Seja A = {<M> | M é uma AFD que não aceita nenhuma cadeia contendo um
número ímpar de 1s }. Mostre que A é decidível.

2. (rngs) M = “Sobre a entrada <A> onde A é um AFD

1. Construa AFD N tal que L(N) é o conjunto de todas as cadeias que não tem
um
número ímpar de 1’s.
2. Rode EQ sobre <A,N>
3. Se EQ aceitar, aceite.
4. Se EQ rejeitar, rejeite.”
Só que, quem é EQ? Tem que definir antes.

EQ = “Sobre a entrada <B,C> onde B é um AFD e C é um AFD.

1. Construa D, tal que L(D) = (L(B) ∩ L(C)’ ) U (L(B)’ ∩ L(C))
2. Rode V sobre D.
3. Se V aceita D, aceite.
4. Se V rejeita D, rejeite.”

Definir V.
V = “Sobre a entrada <D>, onde D é um AFD:
1. Marque o estado inicial de D.
2. Repita até que nenhum estado novo venha a ser marcado:
3. Marque qualquer estado que tem uma transição chegando nele a partir
de qualquer estado que já esteja marcado.
4. Se nenhum estado de aceitação está marcado, aceite; caso contrário, rejeite.”
(phtg) M = “Sobre a entrada <A>, onde A eh um AFD:
1. Construa um AFD N tal que L(N) eh o conjunto de todas as cadeias que tenha
um
numero impar de 1’s
2. Construa um AFD H de modo de que L(H) = L(N) ∩ L(A)
3. Rode V sobre H
4. Se V aceitar, aceite
5. Se V rejeitar, rejeite”

03(3.0). Seja INFINITAafd = { <A> | A é um AFD e L(A) é uma linguagem infinita}.

Mostre que INFINITAafd é decidível.

(rngs) M = “Sobre a entrada <A>, onde A é um AFD:

1. Construa um AFD, B, tal que B reconhece todas as cadeias com o tamanho
maior
ou igual a k, onde k = número de estados do AFD A.
2. Construa um AFD C, tal que L(C) = L(A) ∩ L(B)
3. Rode V sobre C.
4. Se V aceitar, rejeite.
5. Se V rejeitar, aceite.”

Esse algoritmo funciona porque um AFD que aceita uma quantidade infinita de cadeias
tem que aceitar cadeias arbitrariamente longas. Logo ele aceita esses AFD’s. Se o
algoritmo aceita um AFD, e o AFD aceita uma cadeia de comprimento k ou mais quer
dizer que em algum momento se passa mais de uma vez pelo mesmo estado, existe
um loop, logo essa cadeia pode ser bombeada de maneira a gerar infinitas cadeias
aceitas.

MP4 2009.2
1. (0.6) Seja A = { B, C | B e C são ERs e L(B) ⊂ L(C)}, prove que L(A) é
decidível.

(phtg) M = “Sobre a entrada <B, C>, onde B e C sao ERs:

1. Converta B para um AFN D equivalente
2. Converta D para um AFD E equivalente
 3. Converta C para um AFN F equivalente
4. Converta F para um AFD G equivalente
5. Rode EQ sobre <E,G>
6. Se EQ aceitar, rejeite
7. Construa um AFD H de modo que L(H) = L(E) - L(G)
8. Rode V sobre <H>
9. Se V aceitar, aceite
10. Se V rejeitar, rejeite

// alguem poderia explicar a partir do passo 7 o que aconteceu ?

2. (0.2) Prove que AMT é reconhecível.

(rngs) M = “ Sobre a entrada <A,w> onde A é um MT e w é uma cadeia:

1. Rode M sobre w.
2. Se M em algum momento entra no estado de aceitação, aceite.
3. Se M em algum momento entra em seu estado de rejeiçao, rejeite.”

3. (0.2) Seja A uma MT e L(A) uma LTD, prove que L(A’) também é LTD.
(phtg) M = “Sobre a entrada <A, w>, onde A eh uma MT:
1. Rode A com a entrada w
2. Se A aceita, rejeite
3. Se A reijeita, aceite”
MP 2009.1
1. Seja A = {<A,B>| A e B são Expressões Regulares e L(A) e L(B) são partes de ∑*}.
Mostre que A é decidível.

(rfccg) Nao achei a prova a baixo completa, pois envolve uma cadeia w não
especificada. Então aqui vai uma breve descriçao do que seria a minha soluçao
Das expressões regulares crie as AFDs correspondentes. Crie uma AFD que
reconheça ∑*, Crie os AFDs correspondente a intersecção de AFD(A) e AFD(B) com
AFD(∑*). Use a subrotina de equivalencia para dectar se L(AFD(A)) eq L(AFD(A)
Interseçao L( ∑*)) e o mesmo para a linguagem B, se ambas linguagens forem
equivalentes aceite, caso contrario rejeite.
M = “Sobre a entrada <A, B, w, ∑>, onde A e B são ER’s, w eh uma cadeia e ∑ eh um
alfabeto:
1. Converta as ER’s A e B para seus AFN’s equivalentes, respectivamente A’ e B’
2. Converta agora os AFN’s A’ e B’ para AFD’s equivalentes, respectivamente C
eD
3. Rode C com a entrada w. Se C aceita e w for parte de ∑*, aceite
 4. Rode D com a entrada w. Se D aceita e w for parte de ∑*, aceite
5. Senao, rejeite

2. (Modificada) Prove que o Problema da Parada eh indecidivel.

PS: Tomem cuidado com a diferença de L(M) e M. M no caso a baixo é uma maquina
de turing, ja L(M) seria sua linguagem. Dito isso, a setença “U é o complemento de M”
esta errada
Amt = { <M, w> | M eh uma MT que reconhece a cadeia w}
Tentar provar que Amt eh decidivel.
M = “Sobre a entrada <N, w>, onde N eh uma MT e w eh uma cadeia:
1. Rode N com a entrada w
2. Se N aceita, aceite
3. Senao , rejeite”

U eh o complemento de M
U = “Sobre a entrada <M, w>, onde M eh uma MT e w eh uma cadeia:
1. Rode M com a entrada w
2. Se M aceita, rejeite
3. Senao, aceite”

Se eu rodar U com a entrada <U, w>?

U = “Sobre a entrada <U, w>:
1. Rode U com a entrada w
2. Se U aceita, rejeita
3. Senao, aceite”

(rngs) Amt = { <M, w> | M eh uma MT que reconhece a cadeia w}

Tentar provar que Amt eh decidivel.
H = “Sobre a entrada <M, w>, onde N eh uma MT e w eh uma cadeia:
1. Rode M com a entrada w
2. Se M aceita, aceite
3. Senao aceita, rejeite”

H subrotina de D
D = “Sobre a entrada <M>, onde M eh uma MT e w eh uma cadeia:
1. Rode H com a entrada <M, <M>>
2. Se H aceita, rejeite
3. Senao, aceite”

Se eu rodar D com a entrada <D>?

D = “Sobre a entrada <<D>>:
 1. Rode D com a entrada <D>
2. Se D aceita, rejeita
3. Senao, aceite”
Contradição clara, logo nem MT H e MT D podem existir.

3. Sabendo que Amt é uma linguagem reconhecível prove que seu

complemento é uma linguagem irreconhecível.

(phtg) Sabemos que Amt eh reconhecivel. Se barrado(Amt) fosse reconhecivel, entao

Amt seria decidivel. Porem, Amt eh nao-decidivel, pela prova utilizada na questao
acima. Entao barrado(Amt) eh nao-reconhecivel.

EE2 - 2013.2

!
(mfl3) Aqui estão as resoluções que eu elaborei do EE2 resolvido na última aula de
monitoria. Fiquem à vontade para comentar (espero que dê para enxergar direito ._.) =)
!
!
!
!