computabilidade e linguagens formais
Download
Skip this Video
Download Presentation
Computabilidade e Linguagens Formais

Loading in 2 Seconds...

play fullscreen
1 / 44

Computabilidade e Linguagens Formais - PowerPoint PPT Presentation


  • 103 Views
  • Uploaded on

Computabilidade e Linguagens Formais. Autómatos de pilha. Gabriel David / Cristina Ribeiro. Autómatos e autómatos de pilha. Os autómatos de pilha estão para as linguagens sem contexto como os autómatos estão para as linguagens regulares. 1. Linguagens regulares. 1*0(1+0)*. 0. Start. 0,1.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Computabilidade e Linguagens Formais' - eman


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
computabilidade e linguagens formais

Computabilidade e Linguagens Formais

Autómatos de pilha

Gabriel David / Cristina Ribeiro

aut matos e aut matos de pilha
Autómatos e autómatos de pilha
  • Os autómatos de pilha estão para as linguagens sem contexto como os autómatos estão para as linguagens regulares

1

Linguagens regulares

1*0(1+0)*

0

Start

0,1

1

2

Start

A

B

Linguagens sem contexto

E  I | E+E | E×E | (E)

I  a | b | Ia | Ib | I0 | I1

ideia
Ideia
  • Autómato de pilha é um -NFA com uma pilha de símbolos
    • Adiciona a possibilidade de memorizar uma quantidade infinita de informação
    • Só tem acesso ao topo da pilha (LIFO), em vez de poder consultar qualquer posição de memória, como os computadores genéricos
  • Funcionamento
    • A parte de controlo lê e consome os símbolos da entrada
    • Transição para novo estado baseada no estado corrente, símbolo de entrada e símbolo no topo da pilha
    • Transição espontânea com 
    • Topo da pilha substituído por cadeia

Controlo de

estados finito

entrada

Aceita/ rejeita

pilha

exemplo do palindroma
Exemplo do palindroma
  • Lwwr = {wwR | w em (0+1)*} palindromas de comprimento par
    • Linguagem sem contexto gerada pela gramática P   | 0P0 | 1P1
  • Construir um autómato de pilha
    • Estado inicial q0 significa que ainda não se atingiu o meio de wwR; vai-se guardando na pilha os símbolos de w
    • A qualquer altura, adivinha-se que já se chegou ao meio (fim de w) e faz-se uma transição  para q1; a pilha contém w, a começar no fundo e a acabar no topo; o não determinismo é simulado pela manutenção dos dois estados
    • Em q1 comparam-se os símbolos de entrada com o topo da pilha; se não houver correspondência, a aposta foi errada e este ramo da computação morre; outro poderá ter sucesso
    • Se a pilha se esvaziar (e a entrada acabar) descobriu-se w e wR
defini o
Definição
  • Autómato de pilha (PDA) P= (Q, , , , q0, Z0, F)
    • Q: conjunto finito de estados
    • : conjunto finito de símbolos de entrada
    • : alfabeto da pilha finito
    • : função de transição (q, a, X) = {(p1,1), …} finito
      • q é um estado, a um símbolo de entrada ou , X um símbolo da pilha
      • p1 é o novo estado, 1 é a cadeia de símbolos da pilha que substitui X no topo
        • 1=  pop do topo da pilha
        • 1= X pilha inalterada
        • 1= YZ X substituído por Z e push do Y a seguir
    • q0: estado inicial
    • Z0: símbolo inicial, conteúdo inicial da pilha
    • F: conjunto de estados de aceitação ou finais
de novo o exemplo
De novo o exemplo
  • PDA de Lwwr P = ({q0,q1,q2}, {0,1}, {0,1,Z0}, , q0, Z0, {q2})
    • Z0 usado para marcar o fundo da pilha e permitir no fim da leitura de wwR passar para o estado de aceitação q2
    • (q0,0,Z0)= {(q0,0Z0)} e (q0,1,Z0)= {(q0,1Z0)} topo da pilha à esquerda
    • (q0,0,0)= {(q0,00)}, (q0,0,1)= {(q0,01)}, (q0,1,0)= {(q0,10)}, (q0,1,1)= {(q0,11)}
    • (q0,,Z0)= {(q1,Z0)}, (q0, ,0)= {(q1,0)}, (q0, ,1)= {(q1,1)}
    • (q1,0,0)= {(q1, )} e (q1,1,1)= {(q1, )}
    • (q1,,Z0)= {(q2,Z0)}
diagrama de transi o
Diagrama de transição

0, Z0/0Z0

1, Z0/1Z0

0, 0/00

0, 1/01

1, 0/10

1, 1/11

  • Nós são estados
  • Start indica o estado inicial
  • Arcos correspondem às transições
    • Etiqueta a,X/α de q para p significa que (q,a,X) contém (p,α)
    • O arco indica a entrada e o topo da pilha antes e depois

0, 0/

1, 1/

Start

q0

q1

q2

, Z0/Z0

, 0/0

, 1/1

, Z0/Z0

descri o instant nea
Descrição instantânea
  • Computação de um PDA
    • Evolui de configuração em configuração, em resposta a símbolos de entrada (ou ) e alterando a pilha
    • Num DFA: toda a informação no estado; num PDA: estado + pilha
  • Descrição instantânea (q,w,)
    • q: estado
    • w: entrada remanescente (em vez de só um símbolo, conveniência)
    • : conteúdo da pilha (topo à esquerda)
  • Passo de um PDA (Q, , , , q0, Z0, F)
    • Se (q,a,X) contiver (p,α), para todas as cadeias w em * e  em *
    • (q, aw, X) ├P (p,w,α)
    • Usa-se ├* para zero ou mais passos (computação)
ainda o exemplo
Ainda o exemplo
  • Entrada w=1111
  • Descrição instantânea (DI) inicial: (q0, 1111, Z0)

(q1, 1111, Z0)

(q0, 1111, Z0)

(q2, 1111, Z0)

(q0, 111, 1Z0)

(q1, 111, 1Z0)

(q2, 11, Z0)

(q1, 11, Z0)

(q0, 11, 11Z0)

(q1, 11, 11Z0)

(q1, 1, 1Z0)

(q0, 1, 111Z0)

(q1, 1, 111Z0)

(q1, , 11Z0)

(q1, , Z0)

(q2, , Z0)

(q0, , 1111Z0)

(q1, , 1111Z0)

princ pios relativos a di
Princípios relativos a DI
  • Se uma sequência de DIs (computação) é legal para um PDA P então a computação que resulta de adicionar uma qualquer cadeia w à entrada em cada DI também é legal
  • Se uma computação é legal para um PDA P então a computação que resulta de adicionar um qualquer conjunto de símbolos abaixo da pilha em cada DI também é legal
    • Teorema 1: Se (q,x,α) ├* (p,y,) então (q,xw,α) ├* (p,yw,)
  • Se uma computação é legal para um PDA P e uma cauda da entrada não é consumida, então a computação que resulta de remover essa cauda da entrada em cada DI também é legal
    • Teorema 2: Se (q,xw,α) ├* (p,yw,) então (q,x,α) ├* (p,y,)
coment rios
Comentários
  • Dados para os quais P nunca olha não podem afectar a sua computação
  • Conceito semelhante à própria noção de linguagem sem contexto: o que está ao lado não influencia a computação
  • Teorema 2 não é o inverso do 1 porque o que está na pilha pode influenciar a computação mesmo sem ser descartado
    • Pode por exemplo ir sendo retirado da pilha um símbolo de cada vez e no último passo repor tudo
linguagens de um pda
Linguagens de um PDA
  • Aceitação por estado final
    • Seja o PDA P = (Q, , , , q0, Z0, F)
    • Linguagem de P aceite por estado final
    • L(P) = {w | (q0,w,Z0) ├* (q,,α)} e q  F
    • Conteúdo final da pilha é irrelevante
  • Exemplo:
    • (q0,wwR,Z0) ├* (q0,wR,wRZ0) ├ (q1,wR,wRZ0) ├* (q1,,Z0) ├ (q2,,Z0)
  • Aceitação por pilha vazia
    • N(P) = {w | (q0,w,Z0) ├* (q,,)}
    • Linguagem aceite por pilha vazia, conjunto de entradas w que P consome esvaziando ao mesmo tempo a pilha (N(P) – pilha nula)
  • Mesmo exemplo: modificação para esvaziar a pilha e obter N(P)=L(P)
    • (q1,,Z0)= {(q2,Z0)} passa a ser (q1,,Z0)= {(q2,)}
    • (q0,wwR,Z0) ├* (q0,wR,wRZ0) ├ (q1,wR,wRZ0) ├* (q1,,Z0) ├ (q2,,)
da pilha vazia ao estado final
Da pilha vazia ao estado final
  • Teorema: Se L = N(PN) para um PDA PN = (Q, , , N, q0, Z0) então existe um PDA PF tal que L = L(PF)
    • Dois métodos de aceitação de uma entrada equivalentes
    • Embora para um PDA P possa ser L(P)  N(P)
    • Partindo de PN, usa-se um novo X0   como símbolo inicial de PF e como marcador do fundo da pilha: PF vê X0 quando pilha de PN vazia

, X0/ 

, X0/ 

Start

p0

q0

pf

PN

, X0/Z0X0

, X0/ 

PF = (Q{p0,pf}, , {X0}, F, p0, X0,{pf})

do estado final pilha vazia
Do estado final à pilha vazia

, any/

, any/

Start

p

p0

q0

PF

, X0/Z0X0

, any/

exemplo de convers o
Exemplo de conversão
  • Defina um PDA que processe sequências de “i” e “e”, significando if e else, construção presente em muitas linguagens de programação, detectando sequências inválidas (sequências que têm mais “e’s” que “i’s” num prefixo)
    • Símbolo inicial Z; pilha com Zn significa que nº i’s - nº e’s = n-1
    • Aceitação por pilha vazia (balanço de mais um “e” que “i”)
    • Conversão para aceitação por estado final

e, Z/ 

i, Z/ZZ

e, Z/ 

i, Z/ZZ

Start

Start

q

r

p

q

, X0/ZX0

, X0/

pilha vazia

Estado final

equival ncia entre pdas e cfgs
Equivalência entre PDAs e CFGs
  • Prova-se que as linguagens sem contexto, definidas por CFG, são as linguagens aceites por pilha vazia por um PDA e portanto também as aceites por estado final por um PDA
  • Ideia: dada uma CFG G construir um PDA que simula as derivações mais à esquerda de G
    • Qualquer forma frásica esquerda não terminal pode ser escrita como xAα, onde A é a variável mais à esquerda. Aα é a cauda.
    • CFG G = (V,T,Q,S)
    • PDA que aceita L(G) por pilha vazia: P = ({q}, T,VT,,q,S)
    • Para cada variável A: (q,,A)={(q,) | A   é produção em G}
    • Para cada terminal a: (q,a,a)={(q,)}
de cfg para pda
De CFG para PDA
  • Dada a CFG
  • Obter um PDA de aceitação por pilha vazia que aceite a mesma linguagem.
    • PN = ({q}, {a,b,0,1,(,),+,×}, {a,b,0,1,(,),+,×,E,I}, , q, E)
    • (q,,I) = {(q,a), (q,b), (q,Ia), (q,Ib), (q,I0), (q,I1)}
    • (q,,E) = {(q,I), (q,E+E), (q,E×E), (q,(E))}
    • (q,a,a) = {(q,)}; (q,b,b)={(q,)}, (q,0,0) = {(q,)}; (q,1,1) = {(q,)}; (q,(,() = {(q,)}; (q,),)) = {(q,)}; (q,+,+) = {(q,)}; (q,×,×) = {(q,)}
  • Só um estado; processamento das variáveis espontâneo; só os terminais consomem entrada

E  I | E+E | E×E | (E)

I  a | b | Ia | Ib | I0 | I1

exerc cio
Exercício
  • Usando a CFG e o PDA para a linguagem das expressões
    • a) obtenha uma derivação mais à esquerda de a(a+b00)
    • b) obtenha o traço da respectiva computação no PDA, isto é, a sequência de Descrições Instantâneas
  • a)
    • E  E×E  I×E  a×E  a×(E)  a×(E+E)  a×(I+E) 
    • a×(a+E)  a×(a+I)  a×(a+I0)  a×(a+I00)  a×(a+b00)
  • b)
    • (q, a(a+b00), E) ├ (q, a(a+b00), EE) ├ (q, a(a+b00), IE) ├
    • (q, a(a+b00), aE) ├ (q, (a+b00), E) ├ (q, (a+b00), E) ├
    • (q, (a+b00), (E)) ├ (q, a+b00), E)) ├ (q, a+b00), E+E)) ├
    • (q, a+b00), I+E)) ├ (q, a+b00), a+E)) ├ (q, +b00), +E)) ├
    • (q, b00), E)) ├ (q, b00), I)) ├ (q, b00), I0)) ├ (q, b00), I00)) ├
    • (q, b00), b00)) ├ (q, 00), 00)) ├ (q, 0), 0)) ├ (q,),)) ├ (q, , )
de pda para cfg
De PDA para CFG
  • Ideia: reconhecer que o evento fundamental num processamento num PDA é o pop final de um símbolo da pilha enquanto se consome entrada
  • Acrescentar variáveis na linguagem para
    • Cada eliminação definitiva de um símbolo X da pilha
    • Cada mudança de estado de p para q ao eliminar X, representada por um símbolo composto [pXq]
  • Regra: do PDA P= (Q, , , N, q0, Z0) construir CFG G= (V, , R, S)
    • Variáveis V: contém S e os símbolos [pXq]
de pda para cfg cont
De PDA para CFG (cont)
  • Produções R:
    • Para todos os estados p, G contém S  [q0Z0p]
      • O símbolo [q0Z0p] gera todas as cadeias w que extraem Z0 da pilha enquanto vão do estado q0 para o estado p, (q0,w,Z0) ├* (p,,)
      • Então S gera todas as cadeias w que esvaziam a pilha
    • Se (q,a,X) contém o par (r,Y1Y2…Yk), k0, a   ou a= então para todas as listas de estados r1,r2,…,rk, G contém

[qXrk]  a[rY1r1][r1Y2r2]…[rk-1Ykrk]

      • Uma forma de extrair X e ir de q a rk é ler a (pode ser ) e usar alguma entrada para extrair Y1 ao ir de r para r1, etc.
exemplo
Exemplo
  • Converter o PDA PN=({q},{i,e},{Z},N,q,Z) numa gramática
    • aceita as cadeias que violam pela 1ª vez a regra de que um “e” deve corresponder a um “i” precedente
  • Solução:
    • só um estado q e só um símbolo de pilha Z
    • Duas variáveis: S, símbolo inicial; [qZq], único símbolo a partir dos estados e símbolos de PN
    • Produções:
      • S  [qZq] (se houvesse mais estados p e r teríamos S[qZp] e S[qZr])
      • De N(q,i,Z)={(q,ZZ)} obter [qZq]i[qZq] [qZq] (se houvesse mais estados p e r teríamos [qZp]i[qZr] [rZp])
      • De N(q,e,Z)={(q,)} obter [qZq]e (Z é substituído por nada)
      • Chamando A a [qZq] fica SA e A  iAA | e
propriedades das cfl
Propriedades das CFL
  • Simplificação das CFGs  forma normal de Chomsky
  • Eliminação de símbolos inúteis
    • Símbolo útil: S * αX * w, w  T*
    • Símbolo gerador: X * w
      • Qualquer terminal é gerador, dele próprio!
    • Símbolo atingível: S * αX
    • Útil = gerador + atingível
    • Eliminar primeiro os não geradores e depois os não atingíveis
  • Exemplo
    • S  AB | a S  a [B não é gerador] S  a
    • A  b A  b [A não é atingível]
elimina o de s mbolos in teis
Eliminação de símbolos inúteis
  • Algoritmo: descobrir os símbolos geradores
    • os terminais são geradores
    • A  α e α só tem geradores; então A é gerador
  • Algoritmo: descobrir os símbolos atingíveis
    • S é atingível
    • A é atingível, Aα; então todos os símbolos em α são atingíveis
elimina o de produ es
Eliminação de produções-
  • Variável anulável: A * 
  • Transformação: B  CAD passa a B  CD | CAD e impede-se que A produza 
  • Algoritmo: descobrir as variáveis anuláveis
    • A  C1 C2 … Ck, todos os Ci são anuláveis; então A é anulável
  • Se uma linguagem L tem uma CFG então L-{} tem uma CFG sem produções-
    • Determinar todos os símbolos anuláveis
    • Para cada A  X1 X2 … Xk se m Xi’s são anuláveis substituir por 2m produções com todas as combinações de presenças de Xi.
    • Excepção: se m=k, não se inclui o caso de todos os Xi ausentes
    • Produções A   são eliminadas
exemplo1
Exemplo
  • Gramática
    • S  AB
    • A  aAA | 
    • B  bBB | 
  • A e B são anuláveis, logo S também
  • S  AB | A | B
  • A  aAA | aA | aA | a
  • B  bBB | bB | b
elimina o de produ es unit rias
Eliminação de produções unitárias
  • Produção unitária: A  B, em que A e B são variáveis
    • Podem ser úteis na eliminação de ambiguidade (ex: linguagem das expressões)
    • Não são imprescindíveis; introduzem passos extra nas derivações
  • Eliminam-se por expansão
    • I  a | b | Ia | Ib | I0 | I1
    • F  I | (E)
    • T  F | T × F
    • E  T | E + T
  • De E  T passar a E  F | T × F a E  I | (E) | T × F e finalmente E  a | b | Ia | Ib | I0 | I1 | (E) | T × F
    • Problema no caso de ciclos
elimina o de produ es unit rias1
Eliminação de produções unitárias
  • Algoritmo: descobrir todos os pares unitários, deriváveis apenas com produções unitárias
    • (A, A) é um par unitário
    • (A, B) é um par unitário e B  C, C variável; então (A, C) é unitário
  • Exemplo: (E, E), (T, T), (F, F), (E, T), (E, F), (E, I), (T, F), (T, I), (F, I)
  • Eliminação: substituir as produções existentes de forma a que para cada par unitário (A, B) se incluam todas as produções da forma A  α em que B  α é uma produção não unitária (incluir A=B)
gram tica sem produ es unit rias
Gramática sem produções unitárias

I  a | b | Ia | Ib | I0 | I1

F  I | (E)

T  F | T × F

E  T | E + T

sequ ncia de simplifica o
Sequência de simplificação
  • Se G é uma CFG que gera uma linguagem com pelo menos uma cadeia diferente de , existe uma CFG G1 que não tem produções-, produções unitárias ou símbolos inúteis e L(G1) O= L(G) – {}
    • Eliminar produções-
    • Eliminar produções unitárias
    • Eliminar símbolos inúteis
forma normal de chomsky cnf
Forma normal de Chomsky (CNF)
  • Todas as CFL sem  têm uma gramática na forma normal de Chomsky: sem símbolos inúteis e em que todas as produções são da forma
    • A  BC (A, B, C variáveis) ou
    • A  a (A variável e a terminal)
  • Transformação
    • Começar com uma gramática sem produções-, produções unitárias ou símbolos inúteis
    • Deixar as produções A  a
    • Passar todos os corpos de comprimento 2 ou mais para só variáveis
      • Variáveis novas D para os terminais d nesses corpos, substituir e D  d
    • Partir corpos de comprimento 3 ou mais em cascatas de produções só com 2 variáveis A  B1B2…Bk para AB1C1, C1B2C2, …
gram tica das express es
Gramática das expressões
  • Variáveis para os terminais em corpos não isolados
    • A  a B  b Z  0 O  1
    • P  + M  × L  ( R  )
    • E  EPT | TMF | LER | a | b | IA | IB | IZ | IO
    • T  TMF | LER | a | b | IA | IB | IZ | IO
    • F  LER | a | b | IA | IB | IZ | IO
    • I  a | b | IA | IB | IZ | IO
  • Substituir corpos compridos
    • E  EC1 | TC2 | LC3 | a | b | IA | IB | IZ | IO
    • T  TC2 | LC3 | a | b | IA | IB | IZ | IO
    • F  LC3 | a | b | IA | IB | IZ | IO
    • C1  PT C2  MF C3  ER
lema da bombagem para cfl
Lema da bombagem para CFL
  • Dimensão de uma árvore de análise
    • Considerar apenas o caso das CNF: árvores binárias em que as folhas são terminais sem irmãos (produções Aa)
    • Numa gramática com árvore de análise CNF e colheita w terminal, se o comprimento do maior caminho for n então |w|  2n-1
  • Seja L uma CFL. Existe uma constante n tal que, para qualquer cadeia z em L com |z|n se pode escrever z=uvwxy
    • |vwx|  n a parte do meio não é demasiado comprida
    • vx   pelo menos uma é não vazia
    • Para todo i  0, uviwxiy  L bombagem dupla, a começar em 0
prova
Prova
  • Obter uma gramática CNF G para L
  • G contém m variáveis. Escolher n=2m. Cadeia z em L |z|  n.
  • Qualquer árvore de análise com caminho mais longo de comprimento até m tem colheita até 2m-1=n/2.
    • z seria demasiado longa; árvore para z tem caminho m+1 ou maior
  • Na figura, o caminho A0…Aka é de comprimento k+1, km
    • Há pelo menos m+1 variáveis no caminho; logo há pelo menos uma repetição de variáveis (de Ak-m a Ak).
    • Supõe-se Ai=Aj com k-m  i < j  k
continua o da prova
Continuação da prova

A0

  • Se cadeia z suficientemente longa, tem que haver repetições de símbolos
  • Divide-se a árvore:
    • w é a colheita da subárvore de Aj
    • v e x são tais que vwx é a colheita de Ai (como não há produções unitárias pelo menos um de v e x é não nulo)
    • u e y são as partes de z à esquerda e à direita de vwx

Ai=Aj

Aj

Ak

a

u v w x y

z

continua o da prova1
Continuação da prova

S

  • Como Ai=Aj, pode-se
    • substituir a subárvore de Ai pela de Aj, obtendo o caso i=0, uwy.
    • substituir a subárvore de Aj pela de Ai, obtendo o caso i=2, uv2wx2y e repetir para i=3, … (bombagem)
  • |vwx|n porque se pegou num Ai próximo do fundo da árvore, k-im, caminho mais longo de Ai até m+1, colheita até 2m=n

A

A

u v w x y

S

S

A

A

w

A

u v x y

u

y

A

v w x

lema da bombagem
Lema da bombagem
  • no caso das LR: o lema da bombagem decorre de o número de estados de um DFA ser finito
    • para aceitar uma cadeia suficientemente comprida tem que haver repetições de estados
  • No caso das CFL: decorre de o número de símbolos numa CFG ser finito
    • para aceitar uma cadeia suficientemente comprida tem que haver repetições (“duplas”) de símbolos

LR (DFA)

CFL (CFG)

provar que uma linguagem n o cfl
Provar que uma linguagem não é CFL
  • Seja L = {0k1k2k | k  1}. Mostre que não é CFL.
    • Supondo que L é uma CFL, existe uma constante n indicada pelo lema da bombagem; tome-se z = 0n1n2n que faz parte de L
    • Fazendo z=uvwxy, sujeito a |vwx|  n e v, x não ambos nulos, temos que vwx não pode conter simultaneamente 0’s e 2’s
    • Caso vwx não contém 2’s; então vx tem só 0’s e 1’s e tem pelo menos um símbolo. Então, pelo lema da bombagem, uwy também deveria pertencer à linguagem. Mas tem n 2’s e menos do que n 0’s ou 1’s e portanto não pertence à linguagem.
    • Caso vwx não contém 0’s: argumento semelhante.
    • Obtém-se contradição em ambos os casos; portanto a hipótese é falsa e L não é uma CFL
problemas na prova
Problemas na prova
  • Seja L = {0k1k | k  1}. Mostre que não é CFL.
    • Supondo que L é uma CFL, existe uma constante n indicada pelo lema da bombagem; tome-se z = 0n1n que faz parte de L
    • Fazendo z=uvwxy, sujeito a |vwx|  n e v, x não ambos nulos, pode acontecer de escolher v= 0k e x=1k
    • Neste caso uviwxiy pertence sempre a L.
    • Não se obtém a contradição pretendida
  • Não se consegue provar que L não é CFL
    • De facto é uma CFL
substitui o
Substituição
  • Seja  um alfabeto; para cada um dos seus símbolos a define-se uma função (substituição) que associa uma linguagem La ao símbolo
    • Cadeias: se w= a1…an então s(w) é a linguagem de todas as cadeias x1…xn tais que xi está em s(ai)
    • Linguagens: s(L) é a união de todos as s(w) tais que w  L
  • Exemplo:
    • ={0,1}, s(0)={anbn | n1}, s(1)={aa,bb}
    • Se w=01, s(w) = s(0)s(1) = {anbnaa | n1}  {anbn+2 | n1}
    • Se L=L(0*), s(L) = (s(0))* = an1bn1…ankbnk, para n1, …, nk qq
  • Teorema: seja L uma CFL e s() uma substituição que associa a cada símbolo uma CFL; então s(L) é uma CFL.
aplica o do teorema da substitui o
Aplicação do teorema da substituição
  • As CFL são fechadas para:
    • União
    • Concatenação
    • Fecho (*) e fecho positivo (+)
    • Homomorfismo
    • Reverso
    • Intersecção com uma LR
      • Intersecção com uma CFL não é garantida
    • Homomorfismo inverso
cfl e intersec o
CFL e intersecção
  • Seja L1 = {0n1n2i | n1, i1} e L2 = {0i1n2n | n1, i1}
  • L1 e L2 são CFL
    • S  AB S  AB
    • A  0A1 | 01 A  0A | 0
    • B  2B | 2 B  1B2 | 12
  • L1  L2 = {0n1n2n | n1}
    • Já está provado que não é CFL
  • Logo as CFL não são fechadas para a intersecção
complexidade das convers es
Complexidade das conversões
  • Conversões lineares no comprimento da representação
    • CFG para PDA
    • PDA de estado final para PDA de pilha vazia
    • PDA de pilha vazia para PDA de estado final
  • Conversão O(n3)
    • PDA para CFG (tamanho da CFG também O(n3))
  • Conversão O(n2)
    • CFG para CNF (tamanho da CNF também O(n2))
propriedades de decis o das cfl
Propriedades de decisão das CFL
  • Teste de linguagem vazia
    • Verificar se S é gerador
      • Com estrutura de dados adequada, O(n)
  • Teste de pertença numa CFL
    • O(n3), usando programação dinâmica, preenchimento de tabela

S  AB | BC

A  BA | a

B  CC | b

C  AB | a

w=baaba

X12: X11X22; X24: X22X34X23X44

problemas n o decid veis
Problemas não decidíveis
  • Não há algoritmo para responder a estas perguntas
    • Uma dada CFG é ambígua?
    • Uma dada CFL é inerentemente ambígua?
    • A intersecção de duas CFL é vazia?
    • Duas CFL dadas são a mesma linguagem?
    • Uma CFL é o “universo” *, em que  é o seu alfabeto?
ad