Você está na página 1de 156
LINGUAGENS REGULARES
LINGUAGENS REGULARES

Prof. Ronaldo R. Goldschmidt

ronaldo.rgold@gmail.com

LINGUAGENS REGULARES

LINGUAGENS REGULARES

LINGUAGENS REGULARES

São linguagens mais simples, segundo Chomsky

Também chamadas de Linguagens do Tipo 3

Permitem desenvolver algoritmos de:

Reconhecimento de formalismos (*)

Geração de formalismos (*)

Conversão entre formalismos (*)

Possuem fortes limitações de expressividade

Ex: Linguagens com duplo balanceamento não são regulares

Pascal, C, Java, dentre outras

Exemplo de aplicação: Análise Léxica

LINGUAGENS REGULARES

Sistema de Estados Finitos:

Modelo matemático de sistemas com entradas e saídas discretas.

Pode assumir um número finito e predefinido de estados.

Cada estado resume informações do passado necessárias para determinar as ações sobre a entrada seguinte.

Ex. Clássico: Elevador

sobre a entrada seguinte. • Ex. Clássico: Elevador • Não memoriza requisições anteriores. • Cada estado
• Não memoriza requisições anteriores. • Cada estado indica “andar corrente” e “direção movimento”.
• Não memoriza requisições anteriores.
• Cada estado indica “andar corrente” e
“direção movimento”.
• Entradas são requisições pendentes.

LINGUAGENS REGULARES

Autômato Finito

Um autômato Finito é um sistema de estados finitos.

Constitui modelo computacional do tipo seqüencial, comum em diversos estudos teórico-formais da computação. Pode ser:

Determinístico (AFD) Estado corrente e símbolo lido determinam um único estado. Não Determinístico (AFN) Estado corrente e símbolo lido determinam um conjunto de estados. Com Movimentos Vazios Dependendo do estado corrente e sem ler

qualquer símbolo, o sistema pode assumir um conjunto de estados.

Movimentos vazios podem ser vistos como transições encapsuladas nas quais, além de uma eventual mudança de estado, nada mais pode ser observado. Ideia análoga ao conceito de encapsulamento das Linguagens de Programação.

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Pode ser interpretado como uma máquina com controle finito constituída de:

Fita

Unidade de Controle

Programa (Função Programa ou Função Transição)

a

a

b

c

c

b

a

a

b

c

Controle
Controle

Fita é finita, dividida em células, cada uma armazenando um símbolo do alfabeto de entrada.

Não é possível gravar sobre a fita. Unidade de controle possui número finito e predefinido de estados. Unidade de controle se desloca para a direita.

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Formalmente: AFD=(Σ,Q,,q 0 ,F)

Σ é um alfabeto de símbolos de entrada

Q é um conjunto finito de estados possíveis

é uma função parcial denominada função programa : Q x Σ Q (p, a) = q é uma transição do estado p para o estado q

q 0 é um elemento de Q, chamado estado inicial

F Q, denominado conjunto de estados finais

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD) Representação Gráfica

Representação por meio de grafos dirigidos.

Estados são nós (vértices)

por meio de grafos dirigidos. Estados são nós (vértices) Transições são arestas, ligando os nós correspondentes.

Transições são arestas, ligando os nós correspondentes. Ex: (p, a)=q

Estados iniciais e finais possuem representação distinta dos demais.

Representações de Transições Paralelas (mesma origem e destino)

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD) Representação Gráfica

Representações Alternativas Outros Autores:

Autômato Finito Determinístico (AFD) – Representação Gráfica Representações Alternativas – Outros Autores:
Autômato Finito Determinístico (AFD) – Representação Gráfica Representações Alternativas – Outros Autores:

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Representação do Processamento

fita com a cadeia w de entrada

a

a

b

b

a a b b
a a b b
a a b b
a a b b
fita com a cadeia w de entrada a a b b Cabeça de leitura Controle Finito

Cabeça de leitura

Controle

Finito

Início do processo de reconhecimento pelo estado inicial q o

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Representação alternativa de uma função programa: tabela de dupla entrada.

Exemplo de uma função programa:

Argumentos:

- Estado Atual

- Valor de Entrada

Saída:

- Próximo Estado

a

b

q

0

q

1

q

2

q

1

q

f

q

2

q

2

q

1

q

f

q

f

q

f

q

f

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Exemplo: AFD que reconhece strings binárias com um número ímpar de

símbolos 1.

Forma Tabular:

0

1

q

o

q

o

q

1

q

1

q

1

q

o

Forma Gráfica:

1 0 0 q o q 1 1
1
0
0
q o
q 1
1

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Exemplo: Seja

processamento:

a cadeia 01110 e o AFD do exemplo anterior. Veja o

(q 0 , 0) = q 0

0

1

1

1

0

0 1 1 1 0
0 1 1 1 0
0 1 1 1 0

(q 0 , 1) = q 1

0

1

1

1

0

0 1 1 1 0
0 1 1 1 0
0 1 1 1 0
Cabeça Cabeça de leitura de leitura Controle Início do AFD em q 0 Controle q
Cabeça
Cabeça
de leitura
de leitura
Controle
Início do
AFD em q 0
Controle
q
0
Finito
Finito
(q 0 , 1) = q 1
(q 1 , 0) = q 1
0
1
1
1
0
0
1
1
1
0
Cabeça
Cabeça
de leitura
de leitura
Controle
Controle
q
0
Finito
Finito

(q 1 , 1) = q 0

0 1 1 1 0 Cabeça de leitura Controle Finito 0 1 1 1 0
0
1
1
1
0
Cabeça
de leitura
Controle
Finito
0
1
1
1
0

q

1

Cabeça de leitura
Cabeça
de leitura

Controle

Finito

q 1

q 1 F

LINGUAGENS REGULARES

Autômato Finito (AF)

A computação de um autômato finito, para uma palavra de

entrada w, consiste na sucessiva aplicação da função programa para cada símbolo de w (da esquerda para a direita) até ocorrer uma condição de parada.

Obs: AF sempre pára (palavra tem comprimento finito)

AF: aceita W quando após último símbolo processado, o estado é final

rejeita W quando após último símbolo processado, o estado não é final.

ou quando a função programa é indefinida para o argumento

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD) Exemplo: AFD que reconhece palavras de * , onde ={a}

M = (∑, Q, , q o , F)

Q = { q o }, ∑ = { a }, F = { q 0 }

Forma Tabular :

a

q

o

q

o

Forma Gráfica : a q o
Forma Gráfica :
a
q o

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Exemplo: AFD que reconhece palavras sobre ={a},

iniciadas com a letra a.

M = (∑, Q, , q o , F)

Q = {q o , q 1 }, ∑ = { a }, F = { q 1 }

Forma Tabular :

a

q

o

q

1

q

1

q

1

Forma Gráfica :

a a q q 1 o
a
a
q
q 1
o

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Ex: Considere a linguagem L = {w / w possui aa ou bb como subpalavra} O AFD M a seguir reconhece L. M = ({a,b}, {q 0 , q 1 , q 2 , q f }, 1 , q 0 , {q f })

q a a 1 q q 0 f b a b b q 2
q
a
a
1
q
q
0
f
b
a
b
b
q
2

a,b

1

a

b

q

0

q

1

q

2

q

1

q

f

q

2

q

2

q

1

q

f

q

f

q

f

q

f

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Exercício: Represente a função programa e os componentes (∑, Q, , q o , F) do AFD M1 abaixo. Em seguida, indique a sequência de processamento de

M1 diante da cadeia 001122120. Qual o tipo de cadeia reconhecida (ou

aceita) por M1?

a sequência de processamento de M1 diante da cadeia 001122120 . Qual o tipo de cadeia

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Exercício: Considere o AFD M2 = ({a,b}, {q 0 , q f }, 2 , q 0 , {q f }) cuja função programa encontra-se definida abaixo. Indique a representação

gráfica de M2. Em seguida, indique a sequência de processamento de M2

diante da cadeia aaba. Qual o tipo de cadeia reconhecida (ou aceita) por

M2?

2

a

b

q

0

q

0

q

f

q

f

q

0

q

f

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Exercício: Represente a função programa e os componentes (∑, Q, , q o , F) do AFD M3 abaixo. Em seguida, indique a sequência de processamento de

M3 diante da cadeia aabbccabc. Quais os tipos de cadeia reconhecidos por

M3?

indique a sequência de processamento de M3 diante da cadeia aabbccabc . Quais os tipos de

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Seja M=(Σ,Q,,q 0 ,F) um AFD. A Função Programa Estendida ou Computação de M, denotada por:

* : Q x Σ * Q

é a função programa : Q x Σ Q estendida para palavras e

indutivamente definida como segue:

(i) * (q, ɛ) = q (base da indução) (ii) * (q, aw) = * ((q,a), w) (passo indutivo)

Portanto, a função programa estendida consiste na sucessiva aplicação da função programa para cada símbolo da palavra, a partir de um dado estado.

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Exemplo de Função Programa Estendida:

Cadeia de entrada: abaa Computação de abaa:

* (q 0 , abaa) = * ((q 0 ,a), baa) = * (q 1 , baa) = * ((q 1 ,b), aa) = * (q 2 , aa) = * ((q 2 ,a), a) = * (q 1 , a) = * ((q 1 ,a), ɛ) =

* (q f , ɛ) = q f

q a a 1 a,b q q 0 b a f b b q 2
q
a
a
1
a,b
q
q
0
b
a
f
b
b
q
2

Portanto, a cadeia abaa é aceita pelo AFD

LINGUAGENS REGULARES

Autômato Finito Determinístico (AFD)

Outro exemplo de Função Programa Estendida:

Cadeia de entrada: babab Complete a computação de babab:

* (q 0 , babab) =

q a a 1 a,b q q 0 b a f b b q 2
q
a
a
1
a,b
q
q
0
b
a
f
b
b
q
2

A cadeia babab é aceita ou rejeitada pelo AFD ?

LINGUAGENS REGULARES

Linguagem Aceita

Seja M=(Σ,Q,,q 0 ,F) um AFD; A Linguagem Aceita ou Linguagem Reconhecida por M, denotada por ACEITA(M) ou L(M) é o conjunto de todas as palavras de Σ * aceitas por M a partir do seu estado inicial q 0 .

L(M)={w/* (q 0 ,w)F}, onde * é a Função Programa Estendida

Analogamente, a Linguagem Rejeitada por M:

REJEITA(M)={w/* (q 0 ,w)F ou * (q 0 ,w) é indefinida}

LINGUAGENS REGULARES

Linguagem Aceita

Exemplo: Seja M=(Σ,Q,,q 0 ,F) o AFD abaixo; A Linguagem Aceita ou Linguagem Reconhecida por M é formada por cadeias que possuem subcadeias aa ou bb.

Σ = {a, b}, Q = {q 0 , q 1 , q 2 , q f }, F = {q f }

q a a 1 a,b q q 0 f b a b b q 2
q
a
a
1
a,b
q
q
0
f
b
a
b
b
q
2

LINGUAGENS REGULARES

Todo autômato M define partição sobre Σ*

ACEITA(M) REJEITA(M)=Σ* ACEITA(M) REJEITA(M)=Ø

Σ* - ACEITA(M) = REJEITA(M)

Σ* - REJEITA(M) = ACEITA(M)

Σ*

ACEITA(M)

REJEITA(M)

Partição de Σ*, induzida por um Autômato Finito M

LINGUAGENS REGULARES

Linguagem Aceita e Linguagem Rejeitada

Exemplo: Seja M=(Σ,Q,,q 0 ,F) o AFD abaixo. ACEITA(M)={| possui aa ou bb como subcadeias}. REJEITA(M)={| não possui aa nem bb como subcadeias}.

Σ = {a, b}, Q = {q 0 , q 1 , q 2 , q f }, F = {q f }

q a a 1 a,b q q 0 f b a b b q 2
q
a
a
1
a,b
q
q
0
f
b
a
b
b
q
2

LINGUAGENS REGULARES

Autômato Finitos Equivalentes

Diferentes

linguagem.

autômatos

finitos

podem

aceitar

uma

mesma

Assim, sendo M 1 e M 2 autômatos finitos:

M 1 é equivalente a M 2 se, e somente se ACEITA(M 1 )=ACEITA(M 2 )

LINGUAGENS REGULARES

Autômato Finitos Equivalentes

Exemplo: Sejam os autômatos M1 e M2 abaixo. Eles são equivalentes?

M1 = (∑, Q, , q o , F)

Q = {q o , q 1 , q 2 }, ∑ = { a,b }, F = { q 1 }

a a, b q o a, b q 1 b q 2
a
a, b
q o
a, b
q 1
b
q 2

M2 = (∑, Q, , q o , F)

Q = {q o , q 1 , q 2 , q 3 }, ∑ = { a,b }, F = { q 1 }

a a, b q o q 1 a, b a, b b q 2 q
a
a, b
q o
q 1
a, b
a, b
b
q 2
q 3

LINGUAGENS REGULARES

Autômato Finitos Equivalentes

Exemplo: Sejam os autômatos M1 e M2 abaixo. Eles são equivalentes?

M1 = (∑, Q, , q o , F)

Q = { q o }, ∑ = { a }, F = { q 0 }

a q o
a
q o

M2 = (∑, Q, , q o , F)

Q = { q o }, ∑ = { a }, F = { q 0 }

a a q o q 1
a
a
q o
q 1

LINGUAGENS REGULARES

Exercícios:

Construa autômatos finitos determinísticos que reconheçam cada uma das seguintes linguagens sobre ={a,b}

a)

{   * : cada a em é imediatamente precedido por um b}

b)

{   * : possui baba como subcadeia}

c)

{   * : não possui aa nem bb como subcadeias}

d)

{   * : possui um número ímpar de a e um número par de b}

e)

{   * : possui aa e bb como subcadeias}

Atenção:

Utilizar a ferramenta JFLAP para implementar e testar cada um dos AFDs construídos no exercícios anterior.

LINGUAGENS REGULARES

Linguagem Regular (Tipo 3)

L é dita uma Linguagem Regular (ou Linguagem do tipo 3) se

existe pelo menos um AFD que aceita L.

Ex: Considere a linguagem L = {w / w possui aa ou bb como subpalavra} Como vimos, o AFD M abaixo reconhece L. Portanto L é uma linguagem

regular. M = ({a,b}, {q 0 , q 1 , q 2 , q f }, 1 , q 0 , {q f })

q a a 1 q q 0 f b a b b q 2
q
a
a
1
q
q
0
f
b
a
b
b
q
2

a,b

1

a

b

q

0

q

1

q

2

q

1

q

f

q

2

q

2

q

1

q

f

q

f

q

f

q

f

LINGUAGENS REGULARES

Atividades Práticas

Lista de Exercícios III Exercícios 1 e 5

Exercício de T1 (Valendo Nota)

Exercício 8 da Lista III: Desenvolva um programa em computador (linguagem a sua escolha) que simule o processamento de qualquer autômato finito determinístico como segue: (a) Entradas: Alfabeto, conjunto de estados, função de transição, estado inicial, conjunto de estados finais e as palavras a serem processadas; (b) Saídas: Condição de parada ACEITA/REJEITA e identificação

do estado de parada.

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN)

LINGUAGENS REGULARES Autômato Finito Não Determinístico (AFN)

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN)

O não determinismo é uma importante generalização dos modelos

de máquinas, sendo de fundamental importância no estudo de modelos para concorrência e das linguagens formais.

A facilidade do não determinismo para AF é expressa no programa, sendo este uma função parcial que: dependendo do estado corrente e do símbolo lido, determina um conjunto de estados do autômato.

Um Autômato Finito Não Determinístico (AFN) pode assumir um conjunto de estados alternativos, como se existisse uma multiplicação de unidades de controle, uma para cada alternativa,

sem compartilhar recursos com as demais. Daí a importância para

modelos concorrentes.

Qualquer AFN pode ser simulado por um AFD, contribuindo para a simplificação dos modelos.

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN)

Formalmente: AFN=(Σ,Q,,q 0 ,F)

Σ é um alfabeto de símbolos de entrada

Q é um conjunto finito de estados possíveis

é uma função parcial denominada função programa :QxΣ2 Q

(p, a) = {q 1 , q 2 ,

, q n }

q 0 é um elemento de Q, chamado estado inicial

F Q, denominado conjunto de estados finais

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN)

Representação diagramática em um AFN de uma transição

do tipo: (p, a) = {q 1 , q 2 ,

, q n }

(AFN) Representação diagramática em um AFN de uma transição do tipo:  (p, a) = {q

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN)

De forma análoga a um AFD, a computação de uma palavra de

entrada w por um AFN consiste na aplicação da função programa para cada símbolo de w (esquerda direita) até ocorrer condição de parada.

Condições de parada em um AFN:

Aceita a entrada w, quando após processar o último símbolo, existe pelo menos um estado pertencente ao conjunto de estados finais.

Rejeita a entrada w, quando:

Após processar o último símbolo, todos os estados alcançados não pertencem ao conjunto de estados finais.

Em algum momento durante o processamento de w, a função programa é indefinida para o argumento.

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN)

Ex: AFN para reconhecer palavras que contenham aa ou bb.

a,b q a a 1 q q 0 f b b q 2
a,b
q
a
a
1
q
q
0
f
b
b
q
2

a,b

a

b

q

0

{q 0 ,q 1 }

{q 0 ,q 2 }

q

1

{q f }

-

q

2

-

{q

f }

q

f

{q

f }

{q

f }

Com este AFN existem 3 caminhos:

O ciclo em q 0 após passar em toda a entrada

O caminho q 0 /q 1 /q f garante a ocorrência de aa

O caminho q 0 /q 2 /q f garante a ocorrência de bb

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN)

Seja M=(Σ,Q,,q 0 ,F) um AFN. A Função Programa Estendida ou Computação de M, denotada por:

* : 2 Q x Σ * 2 Q é a função programa : Q x Σ 2 Q estendida para palavras e conjuntos de estados, indutivamente definida como segue:

(i) * (P, ɛ) = P (base da indução) (ii) *(P,aw)= *(qP (q,a),w) (passo indutivo)

Transição estendida:

*({q 1 , q 2 ,

q n },a) = (q 1 , a)  (q 2 , a)

,

 (q n , a)

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN)

Exemplo de Função Programa Estendida:

Cadeia de entrada: abaa Computação de abaa:

* ({q 0 }, abaa) = * ((q 0 , a), baa) = * ({q 0 , q 1 }, baa) = * ((q 0 ,b)  (q 1 ,b), aa) = * ({q 0 , q 2 }, aa) = * ((q 0 ,a)  (q 2 ,a), a) = * ({q 0 , q 1 }, a) = * ((q 0 ,a)  (q 1 ,a), ɛ) =

* ({q 0 , q 1 , q f }, ɛ) = {q 0 , q 1 , q f } F 

a,b q a a 1 a,b q q 0 f b b q 2
a,b
q
a
a
1
a,b
q
q
0
f
b
b
q
2

Portanto, a cadeia abaa é aceita pelo AFN

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN)

Outro exemplo de Computação:

Cadeia de entrada: abbaba Computação de abbaba:

* ({q 0 }, abbaba) =

a,b q a a 1 a,b q q 0 f b b q 2
a,b
q
a
a
1
a,b
q
q
0
f
b
b
q
2

A cadeia abbaba é aceita pelo AFN ?

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN)

Outro exemplo de Computação:

Cadeia de entrada: ababa Computação de ababa:

* ({q 0 }, ababa) =

a,b q a a 1 a,b q q 0 f b b q 2
a,b
q
a
a
1
a,b
q
q
0
f
b
b
q
2

A cadeia ababa é aceita pelo AFN ?

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN) e Linguagem Aceita

Seja M=(Σ,Q,,q 0 ,F) um AFN; A Linguagem Aceita ou Linguagem Reconhecida por M, denotada por ACEITA(M) ou L(M) é o conjunto de todas as palavras de Σ * tais que existe pelo menos um caminho alternativo que aceita a palavra a partir do seu estado inicial {q 0 }.

L(M) = {w / * ({q 0 },w) F  }

Analogamente, a Linguagem Rejeitada por M:

REJEITA(M)={w / * ({q 0 },w) F = ou * ({q 0 },w) é indefinida}

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN) e Linguagem Aceita

Exemplo: Seja M=(Σ,Q,,q 0 ,F) o AFN abaixo; A Linguagem Aceita ou Linguagem Reconhecida por M é formada por cadeias que possuem subcadeias aa ou bb.

Σ = {a, b}, Q = {q 0 , q 1 , q 2 , q f }, F = {q f }

a,b q a a 1 a,b q q 0 f b b q 2
a,b
q
a
a
1
a,b
q
q
0
f
b
b
q
2

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN) e Linguagem Aceita

Exemplo: Seja a linguagem L={w / w possui aaa como sufixo}

sobre o alfabeto {a,b}. Construa um AFN M tal que L=ACEITA(M).

M=({a,b}, {q 0 , q 1 , q 2 , q f }, , q 0 , {q f })

q 1 , q 2 , q f },  , q 0 , {q f

Os estados q 1 , q 2 e q f são os marcadores das ocorrências de “a”.

LINGUAGENS REGULARES

Autômato Finito Não Determinístico (AFN) e Linguagem Aceita

Exercício: Seja a linguagem L={w / w possui aaa como sufixo}

sobre o alfabeto {a,b}. Construa um AFD M tal que L=ACEITA(M).

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Teorema: A classe dos Autômatos Finitos Determinísticos é

equivalente à classe dos Autômatos Finitos Não Determinísticos.

Demonstração: (Menezes, 2005, p.58)

AFD
AFD
Determinísticos. Demonstração: (Menezes, 2005, p.58) AFD AFN 1º. Mostrar que a partir de um AFD qualquer
AFN
AFN

1º. Mostrar que a partir de um AFD qualquer M D é possível construir um AFN M N que realiza as mesmas computações do M D . Isso é imediato pois basta adaptar a função programa de M D de forma que as saídas sejam conjuntos unitários formados pelos estados definidos na função original, ou seja, sendo:

D : Q x Σ Q, tal que: (p, a) = q, faz-se a seguinte adaptação:

N :QxΣ2 Q , tal que: (p, a) = {q}

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Demonstração: (cont.1) 2º. Mostrar que a partir de um AFN qualquer M N é possível construir um AFD M D que realiza as mesmas computações do M N .

Seja M N = (, Q N , N , q 0 , F N ) um AFN qualquer.

Construímos um AFD M D = (, Q D , D , q 0 , F D ) da seguinte forma:

a) Q D é o construído a partir de todas as combinações, sem repetições, de estados de Q N .

Cada estado de Q D é denotado por: q 1 q 2

q n , onde q i Q N , para i {1, 2,

, n}

É importante observar que a ordem dos elementos não distingue os estados. Exemplo: q u q v = q v q u

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Demonstração: (cont.2) 2º. Mostrar que a partir de um AFN qualquer M N é possível construir um AFD M D que realiza as mesmas computações do M N .

Seja M N = (, Q N , N , q 0 , F N ) um AFN qualquer.

Construímos um AFD M D = (, Q D , D , q 0 , F D ) da seguinte forma:

b) D : Q D x  Q D é tal que:

D (q 1

q

n

, a) = p 1

p

m , se e somente se, N * ({q 1 ,

c) q 0 é o estado inicial

d) F D é o conjunto de todos os estados q 1 q 2

q n  Q D

,

q

n }, a) = {p 1

p

m }

tal que alguma componente q i

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Demonstração: (cont.3)

A demonstração de que o AFD M D simula as mesmas computações do AFN M N . É por indução no tamanho de uma palavra qualquer w   * . Deve-se mostrar que:

D * (q 0 , w) = q 1

q

u

, se e somente se, N * ({q 0 }, w) = {q 1 ,

, q u }

a)

Base de Indução. Seja w tal que |w| = 0. Portanto, w = , e:

D * (q 0 , ) = q 0 , se e somente se, N * ({q 0 }, ) = {q 0 } é verdadeiro pela definição de função programa estendida;

b)

Hipótese de Indução. Seja w tal que |w| = n e n 1. Suponha verdadeiro que:

D * (q 0 , w) = q 1

q

u

, se e somente se, N * ({q 0 }, w) = {q 1 ,

, q u };

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Demonstração: (cont.4)

b)

Hipótese de Indução. Seja w tal que |w| = n e n 1. Suponha verdadeiro que:

D * (q 0 , w) = q 1

q

u , se e somente se, N * ({q 0 }, w) = {q 1 ,

,

q u };

c)

Passo de Indução. Seja w tal que |wa| = n + 1 e n 1. Então, deseja-se mostrar que:

D * (q 0 , wa) = p 1

equivale, pela hipótese de indução, a:

p

v , se e somente se, N * ({q 0 }, wa) = {p 1 ,

,

p v }. Essa afirmação

D (q 1

verdadeiro pela própria definição de D .

q

u , a) = p 1

p

v

, se e somente se, N * ({q 1 ,

,

q u }, a) = {p 1 ,

, p v },

o que é

Logo, M D simula M N e, portanto, as classes de AFD e AFN são equivalentes.

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Teorema: A classe dos Autômatos Finitos Determinísticos é

equivalente à classe dos Autômatos Finitos Não Determinísticos.

AFD
AFD
à classe dos Autômatos Finitos Não Determinísticos. AFD AFN Obs: Determinismo x Não Determinismo Muitas vezes
AFN
AFN

Obs: Determinismo x Não Determinismo

Muitas vezes é mais fácil desenvolver um AFN do que um AFD,

pois as soluções deterministas, em geral, são não triviais e

envolvem um número possivelmente grande de estados. Em seguida, a partir do AFN pode-se construir o AFD.

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Exemplo: Considere o AFN reconhecedor da linguagem L={w / w possui aaa

como sufixo} sobre o alfabeto {a,b}:

M=({a,b}, {q 0 , q 1 , q 2 , q f }, , q 0 , {q f })

q 1 , q 2 , q f },  , q 0 , {q f

Construa um AFD a partir dele. Seja M D =({a,b}, Q D , D , q 0 , F D )

Q D = {q 0 , q 1 , q 2 , q f , q 0 q 1 , q 0 q 2 ,

F D = {q f , q 0 q f , q 1 q f , q 2 q f ,

Obs: Q D e F D são combinações de estados de Q e F

, q 0 q 1 q 2 q f }

, q 0 q 1 q 2 q f }

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Exemplo (cont.): M=({a,b}, {q 0 , q 1 , q 2 , q f }, , q 0 , {q f })

q 1 , q 2 , q f },  , q 0 , {q f

M D =({a,b}, Q D , D , q 0 , F D ) Q D = {q 0 , q 1 , q 2 , q f , q 0 q 1 , q 0 q 2 ,

F D = {q f , q 0 q f , q 1 q f , q 2 q f ,

, q 0 q 1 q 2 q f }

q 0 q 1 q 2 q f }

 

,

D

a

b

q 0

q 0 q 1

q 0

q 0 q 1

q 0 q 1 q 2

q 0

q 0 q 1 q 2

q 0 q 1 q 2 q f

q 0

q 0 q 1 q 2 q f

q 0 q 1 q 2 q f

q 0

 q 0 q 1 q 2 q f   q 0  Por simplicidade,

Por simplicidade, foram explicitados os estados para os quais a função programa está definida. Além disso, os estados foram renomeados para p 0 q 0 , p 1 q 0 q 1 , p 2 q 0 q 1 q 2 e p f q 0 q 1 q 2 q f .

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Exemplo: Considere o AFN reconhecedor da linguagem L={w / w possui aa

ou bb como subcadeias} sobre o alfabeto {a,b}:

M=({a,b}, {q 0 , q 1 , q 2 , q f }, , q 0 , {q f })

a,b q a a 1 a,b q q 0 f b b q 2
a,b
q
a
a
1
a,b
q
q
0
f
b
b
q
2

Construa um AFD a partir dele.

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Exemplo: Elabore um AFN reconhecedor da linguagem L={w / w possui aa

ou bb como subcadeias e ccc como sufixo} sobre o alfabeto {a,b,c} e, em seguida, converta-o em um AFD.

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Exercícios: Converta os AFN a seguir em AFD:

a)

b)

LINGUAGENS REGULARES Equivalência entre AFD e AFN Exercícios: Converta os AFN a seguir em AFD: a)
LINGUAGENS REGULARES Equivalência entre AFD e AFN Exercícios: Converta os AFN a seguir em AFD: a)

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Exercícios: Converta os AFN a seguir em AFD:

c)

LINGUAGENS REGULARES Equivalência entre AFD e AFN Exercícios: Converta os AFN a seguir em AFD: c)

LINGUAGENS REGULARES

Equivalência entre AFD e AFN

Como:

Toda linguagem L é regular se existe pelo menos um AFD M tal que ACEITA(M)=L. A classe dos AFN é equivalente à classe dos AFD

Podemos concluir que:

Dada uma linguagem L, se existe pelo menos um AFN M tal que ACEITA(M)=L, então L é uma linguagem regular.

Linguagens Aceitas por AFN são, portanto, Linguagens Regulares (Tipo 3)

LINGUAGENS REGULARES

Autômato Finito com Movimentos Vazios

Movimentos

vazios

determinísticos.

generalizam

os

movimentos

não

Um movimento vazio é uma transição sem leitura de símbolo algum da fita.

AFs com movimentos vazios facilitam construções e demonstrações relacionadas a autômatos.

Definição: Um AFN com Movimentos Vazios (AFN ) é um autômato M tal que: M=(Σ,Q,,q 0 ,F), onde:

:Q x (Σ{})2 Q e

(p, ) = {q 1 , q 2 , autômato.

, q n } é um movimento vazio ou transição vazia do

LINGUAGENS REGULARES

Autômato Finito com Movimentos Vazios

Supondo um AFN =(Σ,Q,,q 0 ,F) tal que:

(q, ) = {p 0 } (q, a 1 ) = {p 1 }

(q, a n ) = {p n } Ilustração diagramática:

q
q
p 1
p 1

0 }  (q, a 1 ) = {p 1 }  (q, a n )

a n

0 }  (q, a 1 ) = {p 1 }  (q, a n )
p 0
p 0
p n
p n

LINGUAGENS REGULARES

Autômato Finito com Movimentos Vazios

Exemplo: Considere o AFN ɛ abaixo que aceita a linguagem L={a i b j / i, j 0}

com Movimentos Vazios Exemplo: Considere o AFN ɛ abaixo que aceita a linguagem L={a i b

LINGUAGENS REGULARES

Autômato Finito com Movimentos Vazios

Exemplo: Considere o AFN ɛ abaixo que aceita a linguagem L={a i b j c k a m / i, j, k, m 0}

que aceita a linguagem L={a i b j c k a m / i, j, k,

Compare com a complexidade do AFD abaixo:

que aceita a linguagem L={a i b j c k a m / i, j, k,

LINGUAGENS REGULARES

Equivalência entre AFN e AFN ɛ

Teorema: A classe dos Autômatos Finitos com Movimentos

Não

Vazios

Determinísticos.

é

equivalente

à

classe

dos

Autômatos

Finitos

Demonstração: (Menezes, 2005, p.65)

AFN ɛ
AFN ɛ
Finitos Demonstração: (Menezes, 2005, p.65) AFN ɛ AFN Obs: Linguagens aceitas por autômatos finitos com
AFN
AFN

Obs:

Linguagens aceitas por autômatos finitos com movimentos vazios são, portanto, Linguagens Regulares (Tipo 3).

LINGUAGENS REGULARES

Equivalência entre AFD, AFN e AFN ɛ

Teorema: A classe dos Autômatos Finitos com Movimentos

Vazios é equivalente à classe dos Autômatos Finitos Determinísticos.

Demonstração: (Transitividade)

AFN ɛ
AFN ɛ
Vazios é equivalente à classe dos Autômatos Finitos Determinísticos. Demonstração: (Transitividade) AFN ɛ AFN AFD
AFN
AFN
Vazios é equivalente à classe dos Autômatos Finitos Determinísticos. Demonstração: (Transitividade) AFN ɛ AFN AFD
AFD
AFD

LINGUAGENS REGULARES

Expressões Regulares

Toda linguagem regular pode ser descrita por uma Expressão

Regular.

Trata-se de um formalismo denotacional, porém gerador, pois

se pode inferir como construir as palavras de uma linguagem.

Expressões regulares são consideradas adequadas para a comunicação humano x humano e, principalmente, para a comunicação humano x máquina.

LINGUAGENS REGULARES

Expressões Regulares

Expressões regulares são notações padronizadas para

caracterizar sequências de textos.

Possuem muita aplicação prática no contexto de busca na

web, recuperação de informação, processamento de textos,

cálculo de freqüências de termos em corpora (coleções de documentos), dentre outras.

Formalmente, uma expressão regular é uma notação algébrica

para caracterizar um conjunto de strings.

LINGUAGENS REGULARES

Expressões Regulares

Exemplo de aplicação no Google® para busca na Web:

“Linguagens Formais” Páginas contendo combinação exata

Linguagens Formais Páginas contendo ambas as palavras

Linguagens OR Formais Páginas contendo pelo menos uma

Linguagens Formais Páginas contendo somente a primeira

Parênteses definem precedência (T1 OR T2) T3

LINGUAGENS REGULARES

Expressões Regulares

Definição: Uma Expressão regular (abreviada por ER) sobre um alfabeto é

indutivamente definida como:

a) Base de Indução

Para qualquer x  , a expressão x é regular e representa a linguagem {x}

A expressão é regular e representa a linguagem vazia

A expressão ɛ é regular e representa a linguagem {ɛ}

b) Passo de Indução: Se r e s são expressões regulares e representam as linguagens R e S, respectivamente, então a expressão:

(r + s) é regular e representa a linguagem R S (União)

(rs) é regular e representa a linguagem RS={uv / u R e v S} (Concatenação)

(r * ) é regular e representa a linguagem R * (Concatenação Sucessiva)

LINGUAGENS REGULARES

Expressões Regulares

Se r é uma expressão regular, a linguagem que ela representa

é chamada Linguagem Gerada por r, cuja notação é:

L(r) ou GERA(r)

A omissão de parênteses em uma ER é usual, respeitando as

seguintes convenções:

A concatenação sucessiva tem precedência sobre a concatenação e a união. A concatenação tem precedência sobre a união.

LINGUAGENS REGULARES

Expressões Regulares

A tabela abaixo apresenta exemplos de expressões regulares e

as correspondentes linguagens geradas:

Expressão Regular

Linguagem Gerada

aa

Somente a palavra aa

ba*

Todas as palavras iniciadas por b, seguidas por zero ou mais “a”

(a+b)*

Todas as palavras sobre {a, b}

(a+b)*aa(a+b)*

Todas as palavras contendo aa como subpalavra

a*ba*ba*

Todas as palavras contendo exatamente dois “b”

(a+b)*(aa+bb)

Todas as palavras terminadas por aa ou bb

(a+ɛ)(b+ba)*

Todas as palavras que não possuem dois “a” consecutivos

LINGUAGENS REGULARES

Expressões Regulares

Exemplo:

(a+b)*(aa+bb):

a e b denotam {a} e {b}, respectivamente

a + b denota {a} {b} = {a, b}

(a + b)* denota {a, b}*

aa denota {a}{a}={aa} e bb denota {b}{b}={bb}

(aa+bb) denota {aa} {bb} = {aa, bb}

(a+b)*(aa+bb) denota {a,b}*{aa, bb}

Portanto, GERA ((a+b)*(aa+bb)) corresponde à linguagem:

Detalhe

a

linguagem

gerada

pela

expressão

regular

{aa, bb, aaa, abb, baa, bbb, aaaa, aabb, abaa, abbb, baaa, babb, bbaa,

bbbb,

}

LINGUAGENS REGULARES

Expressões Regulares

Exercício:

Defina expressões regulares para as seguintes linguagens sobre {a,b}:

a) Cadeias que possuam aacomo prefixo e bbcomo sufixo.
b) Cadeias que só possuam três “a” não necessariamente consecutivos.
c) Cadeias em que todo “a” seja seguido de um único “b”.
d) Cadeias em que todo “a” seja precedido de um único “b”.
e) Cadeias que não possuam dois “b” consecutivos.
f) Cadeias iniciadas por aaou bbe que possuam “ab” como subcadeia.
g) Cadeias sem ocorrências de “b”.

h) Cadeias aaou bbou “ab”.

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se r é uma expressão regular, então GERA(r) é uma linguagem

regular.

Demonstração: (Menezes, 2005, p.68)

Seja r uma expressão regular, precisamos mostrar que existe um AF M tal que ACEITA(M) = GERA(r).

Na construção de M, ACEITA(M) = GERA(r) é demonstrada por indução no

número de operadores.

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se r é uma expressão regular, então GERA(r) é uma linguagem

regular.

Demonstração: (Cont.1)

a) Base de Indução. Seja r uma expressão regular com zero operadores.

Então r só pode ser da forma:

r = ou r = ou r = x (onde x  ) Os AF abaixo aceitam as linguagens acima:

M 1 = (, {q 0 }, 1 , q 0 , ) M 2 = (, {q f }, 2 , q f , {q f }) M 3 = ({x}, {q 0 , q f }, 3 , q 0 , {q f })

, {q f },  2 , q f , {q f }) M 3 =

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se r é uma expressão regular, então GERA(r) é uma linguagem

regular.

Demonstração: (Cont.2)

b) Hipótese de Indução. Seja r uma expressão regular com até n > 0 operadores. Suponha que seja possível definir um AF M tal que:

ACEITA(M) = GERA(r)

c) Passo de Indução. Seja r uma expressão regular com até n + 1 operadores. Então r pode ser representada por um dos seguintes casos (onde r 1 e r 2 possuem juntos, no máximo, n operadores):

r

r

r

= r 1 + r 2 = r 1 r 2 = r 1

*

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se r é uma expressão regular, então GERA(r) é uma linguagem

regular.

Demonstração: (Cont.3)

c)

Passo de Indução. Seja r uma expressão regular com até n + 1 operadores. Então r pode ser representada por um dos seguintes casos (onde r 1 e r 2 possuem juntos, no máximo, n operadores):

r = r 1 + r 2

r = r 1 r 2

*

r = r 1

Por hipótese de indução, é possível construir os autômatos:

M 1 = (1 , Q 1 , 1 , q 01 , {q f1 })

tais que:

ACEITA(M 1 ) = GERA(r 1 )

e

e

M 2 = (2 , Q 2 , 2 , q 02 , {q f2 })

ACEITA(M 2 ) = GERA(r 2 )

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se r é uma expressão regular, então GERA(r) é uma linguagem

regular.

Demonstração: (Cont.4)

c) Por hipótese de indução, é possível construir os autômatos:

M 1 = (1 , Q 1 , 1 , q 01 , {q f1 })

e

M 2 = (2 , Q 2 , 2 , q 02 , {q f2 })

tais que: ACEITA(M 1 ) = GERA(r 1 ) e ACEITA(M 2 ) = GERA(r 2 )

Sem perda de generalidade, assume-se que M 1 e M 2 possuem exatamente um estado final e que Q 1 Q 2 = .

Assim, os seguintes AFN que aceitam GERA(r) podem ser construídos para cada operação:

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se r é uma expressão regular, então GERA(r) é uma linguagem

regular.

Demonstração: (Cont.5)

c) Assim, os seguintes AFN que aceitam GERA(r) podem ser construídos para cada operação: (i) r = r 1 + r 2

Seja M = (1  2 , Q 1 Q 2 {q 0 , q f } , , q 0 , {q f }):

 {q 0 , q f } ,  , q 0 , {q f }):

A partir de q 0 , M realiza transições para os estados q 01 e q 02 . M 1 e M 2 processam de forma não determinística e, basta que um deles aceite a

entrada , para que M também aceite.

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se r é uma expressão regular, então GERA(r) é uma linguagem

regular.

Demonstração: (Cont.6)

c) Assim, os seguintes AFN que aceitam GERA(r) podem ser construídos para cada operação: (ii) r = r 1 r 2

Seja M = (1  2 , Q 1 Q 2 , , q 01 , {q f2 }):

, Q 1  Q 2 ,  , q 0 1 , {q f 2

Ao processar os módulos M 1 e M 2 em sequência, M aceita uma entrada se, e somente se, o prefixo pertencer a ACEITA(M 1 ) e o sufixo pertencer a ACEITA(M 2 ).

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se r é uma expressão regular, então GERA(r) é uma linguagem

regular.

Demonstração: (Cont.7)

c)

Assim, os seguintes AFN que aceitam GERA(r) podem ser construídos para cada operação: (iii) r = r 1

Seja M = (1 , Q 1 {q 0 , q f } , , q 0 , {q f }):

*

 {q 0 , q f } ,  , q 0 , {q f }):

A transição vazia de q 0 para q f garante a aceitação da palavra vazia e o ciclo de q f1 para q 01 permite o sucessivo processamento de M 1 para assegurar o reconhecimento de duas ou mais concatenações sucessivas.

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se r é uma expressão regular, então GERA(r) é uma linguagem

regular.

Demonstração: (Conclusão)

Assim, dada r uma expressão regular, mostramos que é sempre possível construir um AF M tal que ACEITA(M) = GERA(r).

Portanto, como existe tal autômato, por definição, GERA(r) é uma linguagem

regular.

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se r é uma expressão regular, então GERA(r) é uma linguagem

regular.

Exemplo: (a+b)*aa é expressão regular. L=GERA ((a+b)*aa) = {aa, aaa, baa, aaaa, abaa, baaa,

}

O AFD ao lado aceita L.

Portanto, L é regular.

q a a 1 q q 0 b a f b b q 2 b
q
a
a
1
q
q
0
b
a
f
b
b
q
2
b

a

LINGUAGENS REGULARES

Expressões Regulares

Teorema: Se L é uma linguagem regular, então existe uma expressão regular r

tal que: GERA(r)=L

Demonstração: (Menezes, 2005, p.71)

Exemplo: L = {w / w possui aa ou bb como subpalavra} é uma linguagem regular.

O AFD aceita L:

q a a 1 a,b q q 0 b a f b b q 2
q
a
a
1
a,b
q
q
0
b
a
f
b
b
q
2

LINGUAGENS REGULARES

Expressões Regulares

Exercício: Construa um AFN que aceita GERA(a * (aa+bb))

Exercício: Construa um AFN que aceita GERA(a * (aa+bb)) Obs: Os estados foram omitidos para fins
Exercício: Construa um AFN que aceita GERA(a * (aa+bb)) Obs: Os estados foram omitidos para fins

Obs: Os estados foram omitidos para fins de simplificação dos esquemas.

LINGUAGENS REGULARES

Expressões Regulares

Exercício: Construa um AFN que aceita GERA(a * (aa+bb)) (cont.)

Construa um AFN que aceita GERA(a * (aa+bb)) (cont.) Sugestão: Experimente o recurso de conversão disponível

Sugestão: Experimente o recurso de conversão disponível no JFLAP

LINGUAGENS REGULARES

Gramática Regular

O conceito de gramática pode ser usado para definir tanto

linguagens regulares como linguagens não regulares.

Entretanto, é possível estabelecer restrições nas regras de

produção de forma a definir a Classe das Linguagens Regulares.

Existe mais de uma forma de definir uma Gramática Regular. Na sequência são apresentadas quatro dessas formas, denominadas Gramáticas Lineares.

LINGUAGENS REGULARES

Gramática Regular

Seja G=(V,T,P,S) uma gramática. Sejam A e B elementos de V e w uma

palavra de T*. Diz-se que G é uma Gramática Linear se todas as suas produções encontram-se em uma e somente uma das seguintes formas:

Gramática Linear à Direita (GLD): A wB ou A w

Gramática Linear à Esquerda (GLE): A Bw

Gramática Linear Unitária à Direita (GLUD): Como GLD e |w| 1

Gramática Linear Unitária à Esquerda (GLUE): Como GLE e |w|