Sobre Autómatos e Linguagens de Programação

Not 01(0+1)*

Em Autómatos e Linguagens de Programação faz-se uma introdução formal à teoria e às técnicas da análise e definição de linguagens de programação.

Os conceitos e as técnicas tratadas são ilustradas num capítulo final, onde é definida uma linguagem de programação simples e implementado um interpretador para essa linguagem.

Dado um programa python,

# file: guide.py
def resposta():
    return 42

print(f"The answer is {resposta()}.\n")

Quando este programa corre, por exemplo

> python guide.py <enter>
> The answer is 42.

o que acontece entre o <enter> na linha python guide.py e aparecer o texto The answer is 42. na consola?

O interpretador do python, entre outras coisas:

Lê o ficheiro guide.py do sistema de ficheiros.
Processa o conteúdo desse ficheiro de forma a determinar se corresponde a um programa válido (em python, claro).
Executa as instruções desse programa, incluindo:
1. A definição da função resposta() e respetivas "sub-instruções".
2. O cálculo do valor da expressão "The answer is {resposta()}.\n".
3. Escrever na consola o valor dessa expressão.

Outro exemplo: uma calculadora "básica".

Para programar uma calculadora para a linha de comandos, o programa deve receber uma string com uma conta e escrever o respetivo resultado. Por exemplo > calc "2+3*4" deve escrever 14.

Quais são as dificuldades de fazer este programa? Há várias:

Temos de saber verificar se o input está "bem formado". Por exemplo 2+3*4 está bem, mas +234** nem por isso...
Exatamente, o que "significa" cada "símbolo"? 2 é 2? E se aparecer em 20?
E como tratar "sequências" de símbolos? 2+3 é sempre 2+3? Mas então 2+3*4 não devia ser 14 mas 20...

Estas são exatamente as questões tratadas em ALP:

Quais são os símbolos (ou letras) e as palavras válidas (isto é, as sequências de símbolos que sabemos tratar)?
Como definir e representar todas as palavras válidas, isto é, a linguagem?
Como distinguir as palavras válidas das inválidas?
Como atribuir significado às palavras válidas? Isto é, como executar um programa?

Objetivos

Ao completar esta disciplina deve conseguir:

Discutir máquinas de estados finitos.
Construir expressões regulares, autómatos e gramáticas para aceitar/gerar linguagens especificadas; Converter entre representações equivalentes.
Determinar o lugar de uma linguagem na Hierarquia de Chomsky e os principais problemas nas definições da sintaxe de linguagens de programação.
Usar gramáticas formais para especificar a sintaxe de linguagens, ferramentas declarativas para gerar analisadores e scanners.
Definir uma semântica formal e uma árvore de sintaxe abstrata para uma linguagem de programação simples.
Explicar como os programas que processam outros programas tratam os outros programas e as vantagens de ter representações de programas.
Escrever um programa para processar alguma representação de código.

Programa & Bibliografia

Programa

Sobre ALP
- Objetivos
- Programa & Bibliografia
- Avaliação
Palavras, Linguagens e Expressões Regulares
- Alfabetos, Palavras e Linguagens
- Expressões Regulares
- < Exercícios >
Autómatos Finitos
- Autómatos Finitos Deterministas
- Computação Não-Determinista
- Minimização e Composição de AFD
- O Pumping Lemma
- < Exercícios >
Gramáticas e Autómatos de Pilha
- Gramáticas Livres de Contexto
- Autómatos de Pilha
- < Exercícios >
Análise Sintática
- Tipos de Análise Sintática
- Limpeza de uma Gramática
- < Exercícios >
- Gramáticas LL
- < Exercícios >
- Gramáticas LR
- < Exercícios >
Representação & Execução de Programas
- Árvore de Sintaxe Abstrata
- Análise Semântica
- Suporte para um Interpretador
- < Exercícios >

Bibliografia

Languages and Machines: An Introduction to the Theory of Computer Science, 2 ed. Thomas A. Sudkamp. Addison Wesley, 1997. (320 páginas)
Compilers: Principles, Techniques and Tools, Alfred V. Aho, Ravi Sethi e Jeffrey D. Ullman. Addison Wesley, 1986. (1038 páginas)

Recursos

Programação em python:
- Livro: How to Think Like a Computer Scientist: Learning with Python 3 Documentation.
- Tutorial: The Python Tutorial em python.org.
- Cheat Sheets: Várias.
Simuladores AFD, AFnD, AP, GIC, ER, ...
- OFLAT This tool is being developed at NOVA-LINCS (at the Computer Science Department of FCT-UNL) by the projects Factor and LEAFs and co-financed by Tezos Foundation and INRIA Foundation.
- Automata Learning Lab
- JFLAP is software for experimenting with formal languages topics including nondeterministic finite automata, nondeterministic pushdown automata, multi-tape Turing machines, several types of grammars, parsing, and L-systems.
ALisP é uma linguagem de programação usada para exemplificar a matéria de análise sintática.
Palavras Portuguesas (NAO) lista de 431114 palavras portuguesas, uma por linha.

Palavras, Linguagens e Expressões Regulares

Neste capítulo são fixadas bases rigorosas para a definição de linguagens de programação e a análise dos respetivos programas.

É necessário começar por definir rigorosamente e sem ambiguidades, isto é, matematicamente, certos conceitos fundamentais como "símbolo" (ou "letra"), "palavra" e "linguagem".

Também são definidas as "expressões regulares", que permitem representar certas linguagens formais de forma compacta.

Com as "expressões regulares" tem-se uma forma rigorosa de definir certas linguagens formais. É o primeiro passo no processo para representar linguagens de programação.

Alfabetos, Palavras e Linguagens

Era uma vez, num reino muito muito distante, ...

Alfabetos, Palavras e Linguagens

Símbolos e Alfabetos

Alfabeto, Símbolo. Um alfabeto é um conjunto finito de símbolos, também designados letras (em inglês: symbols, letters, tokens).

Os alfabetos são normalmente representados por maiúsculas gregas $Σ$ (sigma) e $Γ$ (gama) e os símbolos por minúsculas romanas $a, b, c, d$ .

Por exemplo:

O alfabeto do português tem os seguintes símbolos: $a, b, c, \dots, x, y, z$ .
Os símbolos $0$ e $1$ formam um alfabeto binário. Outro alfabeto binário muito usado em ALP é ${a, b}$ .
Os números naturais podem ser escritos em base 10 usando o alfabeto ${0, 1, 2, 3, 4, 5, 6, 7, 8, 9}$ .
Para as expressões algébricas usa-se o alfabeto ${0, 1, \dots, 8, 9} \cup {+, -, \times, \div, (,)}$ .

As linguagens de programação têm um conjunto de palavras reservadas, como while, if, etc. que são atómicas, isto é, não podem ser divididas.

O símbolo "if" não é, em termos da linguagem de programação, um "i" seguido de um "f", mas um símbolo que não pode ser decomposto.

Já fragmentos de programas como if (x == 42) { return "yes"; } else { return "no"; } são compostos. Nesta instrução condicional (x == 42) é o teste (ou guarda), { return "yes"; } o bloco positivo e { return "no"; } o bloco negativo. Neste caso a instrução resulta de uma regra do tipo

Condicional := if ( Condição ) { Instruções } else { Instruções }

Por sua vez a guarda (Condição) e os blocos de Instruções podem ser decompostos, até chegarmos a símbolos atómicos como (, ==, return, etc.

Palavras

Palavra. Uma palavra sobre um alfabeto $Σ$ é uma sequência finita de símbolos desse alfabeto (em inglês: word).

Formalmente, uma palavra de comprimento $n$ é uma função $p : {1, 2 \dots, n} \to Σ$ que a cada inteiro $i \in {1, 2, \dots, n} \mapsto p (i) \in Σ$ .

As palavras são normalmente representadas pelas minúsculas romanas $p, q, u, v, w, x, y, z$ .

Palavra Vazia. A palavra vazia (em inglês: empty word, null, nil) é a única palavra de comprimento 0 e representa-se pela letra grega $λ$ (lambda). Também é comum usar-se $ϵ$ ou $ε$ (epsilon) para representar a palavra vazia.

Não confundir a palavra $λ$ (que tem comprimento 0) com um símbolo. Estes, como palavras, têm comprimento um.

Propriedades do Comprimento das palavras

O comprimento da palavra $p$ é normalmente representado por $∣ p ∣$ .
Para a palavra vazia, $∣ λ ∣ = 0$ . Em geral, se $p = a_{1} \dots a_{n}$ então $∣ p ∣ = n$ . Isto é, $∣ a_{1} \dots a_{n} ∣ = n$ .

Fecho de Kleene

Dado um alfabeto, interessa considerar todas as palavras que podem ser formadas com essas letras.

Por exemplo, para representar números em binário usam-se palavras sobre ${0, 1}$ . Mas, depois de se definirem todas as palavras, há que determinar quais as que interessam. Por exemplo, embora $00$ e $0$ sejam palavras binárias (distintas), se interpretadas normalmente, ambas correspondem ao número $0$ e portanto há aqui uma ambiguidade. Será possível definir uma linguagem que continue a representar todos os números mas sem ambiguidades?

Para abordar estas questões tem de se começar por definir rigorosamente o conjunto de todas as palavras que se podem obter com um dado alfabeto.

Fecho de Kleene. O fecho do alfabeto $Σ$ é o conjunto de todas as palavras sobre $Σ$ , representa-se por $Σ^{*}$ e fica definido pelas seguintes condições:

base $λ \in Σ^{*}$ .

passo Se $p \in Σ^{*}$ e $a \in Σ$ então $p a \in Σ^{*}$ .

fecho Qualquer palavra $p \in Σ^{*}$ só pode ser obtida por um número finito de aplicações do passo a começar na palavra vazia. E reciprocamente, qualquer palavra obtida a partir de $λ$ por aplicações do passo em número finito está em $Σ^{*}$ .

Esta definição exclui a possibilidade de palavras infinitas. Mas isto não significa que exista um limite ao comprimento das palavras em $Σ^{*}$ . Pelo contrário, se $Σ \neq = \emptyset$ então, para qualquer $n \in N$ existe pelo menos uma palavra de comprimento $n$ .

Exercício: Porquê? E porque é que acima é referida a condição " $Σ \neq = \emptyset$ "? O que é $\emptyset^{*}$ ?

No fecho de um alfabeto também ficam excluídas palavras formadas por símbolos de outros alfabetos. Por exemplo, a palavra $abc$ não está em ${a, b}^{*}$ .

Logo a primeira condição na definição de $Σ^{*}$ inclui a palavra vazia. Como muitas vezes é conveniente excluir $λ$ define-se $Σ^{+} = \cup_{n > 0} Σ^{n} = Σ Σ^{*} .$

Exercício: Mostre que $Σ^{+} = Σ^{*} ∖ {λ}$ .

Operações com Palavras

Comprimento

Ainda não foi apresentada uma definição rigorosa de comprimento de uma palavra. Usando um esquema recursivo:

Comprimento. A função comprimento é calculada pelas seguintes regras:

base $∣ λ ∣ = 0$ .

passo $∣ p a ∣ = ∣ p ∣ + 1$ , com $p \in Σ^{*}, a \in Σ$ .

Por exemplo, para calcular $∣ abc ∣$ :

Como $abc \neq = λ$ , aplicar-se a regra do passo: fazendo $p a = abd$ tem de ser $p = ab$ e $a = c$ , e obtem-se $∣ abc ∣ = ∣ ab ∣ + 1$ .
Ainda não está calculado o valor de $∣ ab ∣$ . Tornando a aplicar o passo: $∣ ab ∣ = ∣ a ∣ + 1$ .
Uma nova aplicação do passo: $∣ a ∣ = ∣ λ ∣ + 1$ .
Finalmente, pela base: $∣ λ ∣ = 0$ , portanto $∣ a ∣ = 0 + 1 = 1$ e, sucessivamente, obtém-se $∣ ab ∣ = 2$ e $∣ abc ∣ = 3$ .

Também é comum usar-se a notação $∣ p ∣_{a}$ para indicar o número de ocorrências do símbolo $a$ na palavra $p$ .

Por exemplo: $∣ aba ∣_{a} = 2, ∣ aba ∣_{b} = 1$ .

Concatenação

O operação fundamental das palavras é a "concatenação". A concatenação de hello com world é helloworld. Para definir rigorosamente esta operação:

Concatenação. A concatenação (ou produto) de duas palavras $u, v \in Σ^{*}$ representa-se por $u \cdot v$ ou apenas $uv$ e é uma operação binária definida por:

base Se $v = λ$ então $u \cdot v = u$ .

passo Se $∣ v ∣ = n > 0$ então

Existe uma palavra $w \in Σ^{*}$ e uma letra $a \in Σ$ tal que $v = w a$ .

$u \cdot v = (u \cdot w) a$ .

Por exemplo, para calcular a concatenação de $ab$ com $cd$ :

O comprimento de $cd$ é 2, portanto temos de aplicar o passo: $ab \cdot cd = (ab \cdot c) d$ .
Precisamos de calcular $ab \cdot c$ . Pela regra do passo: $ab \cdot c = (ab \cdot λ) c$ .
Finalmente, $ab \cdot λ$ é calculada pela regra base: $ab \cdot λ = ab$ .
Andando para trás: $ab \cdot c = (ab \cdot λ) c = (ab) c = abc$ e, portanto, $ab \cdot cd = (ab \cdot c) d = abcd$ .

Potência

A repetição de concatenações define as potências, tal como a multiplicação dos números.

Potências. As potências da palavra $p \in Σ^{*}$ são (informalmente): $p^{0} = λ, p^{1} = p, p^{2} = pp, \dots, p^{n} = p^{n - 1} p .$

Por exemplo, $(01)^{2} = 0101$ mas $01^{2} = 011$ , seguindo as regras normais de precedência das operações.

Inversa

Finalmente, as palavras (enquanto sequências de símbolos) podem ser escritas "de trás para a frente":

Inversa. A inversa de $p \in Σ^{*}$ , representada por $p^{R}$ (ou $p^{- 1}$ ) é calculada pelas seguintes regras:

base Se $p = λ$ então $p^{R} = p$ .

passo Se $∣ p ∣ = n > 0$ então $p = q a, a \in Σ$ e $p^{R} = a q^{R}$ .

Por exemplo, se $p = abcd$ então $p^{R} = dcba$ .

Propriedades das Operações de Palavras

O que acontece à inversa de duas palavras concatenadas?

Para quaisquer palavras $u, v \in Σ^{*}$ , $(uv)^{R} = v^{R} u^{R}$

Demonstração (informal): Se $u = λ$ a conclusão é evidente. Caso contrário $u = u_{1} u_{2} \dots u_{n}$ e $v = v_{1} v_{2} \dots v_{m}$ com todos os $u_{i}, v_{j} \in Σ$ . Então: $(uv)^{R} = (u_{1} u_{2} \dots u_{n} v_{1} v_{2} \dots v_{m})^{R} = v_{m} \dots v_{2} v_{1} u_{n} \dots u_{2} u_{1} = (v_{m} \dots v_{2} v_{1}) (u_{n} \dots u_{2} u_{1}) = v^{R} u^{R} □$

O fecho também tem propriedades interessantes.

Se $Σ, Γ$ forem alfabetos,

$Σ^{*} = \cup_{n \geq 0} Σ^{n}$ .

$Σ \subseteq Σ^{*}$ .

$\emptyset^{*} = {λ}$ .

Se $Σ \neq = \emptyset$ então $Σ^{*}$ é infinito.

Se $Σ \subset Γ$ então $Σ^{*} \subset Γ^{*}$ .

Por fim, a concatenação tem propriedades semelhantes às do produto (de números).

Sejam $u, v, w \in Σ^{*}$ .

associativa $u (v w) = (uv) w$ .

elemento neutro $u λ = λ u = u$ .

não comutativa Em geral, $uv \neq = vu$ .

aditiva $∣ uv ∣ = ∣ u ∣ + ∣ v ∣$ .

unicidade Cada palavra só pode ser escrita de uma única forma como concatenação de símbolos. Isto é, se $u = v$ e $u = u_{1} \dots u_{n}$ e $v = v_{1} \dots v_{m}$ então $n = m$ (mesmo comprimento) e $u_{i} = v_{i}$ para cada $i = 1, \dots, n$ (mesmos símbolos) .

Ordenações de Palavras

Uma palavra pode "conter" outra. Por exemplo, palavra contém pala no início, ala no "meio" e lavra no fim. Estes três casos ilustram as definições que se seguem:

Subpalavra, prefixo, sufixo. Sejam $p, q, u, v \in Σ^{*}$ .

subpalavra $p \leq q$ se $q = u p v$ .

prefixo $p \leq_{P} q$ se $q = p v$ .

sufixo $p \leq_{S} q$ se $q = u p$ .

Fica claro que os prefixos são casos particulares das subpalavras (quando $u = λ$ ) e que cada palavra é subpalavra de si própria (quando $u = λ = v$ ).

Outro caso importante é a ordem lexicográfica (dos dicionários), onde se usa a ordem das letras para ordenar as palavras.

Ordem Lexicográfica. Supondo que o alfabeto está ordenado, $Σ = {a_{1} < a_{2} < \dots < a_{n}}$ . Então $p \leq_{L} q$ se:

$p \leq_{P} q$ .

Caso contrário, $p = u s_{i} v$ e $q = u s_{j} w$ com $s_{i} < s_{j}$ .

Esta definição abrange dois casos:

por < porque porque por é um prefixo de porque.
porque < portugal porque, como porque = por_q_ue e portugal = por_t_ugal então portugal e porque têm um prefixo comum, por, e "divergem primeiro" nas letras q e t. Como q < t então porque < portugal.

A ordem lexicográfica tem um problema interessante: Quantas palavras existem entre $0$ e $1$ , num alfabeto binário?

Por exemplo $00 <_{L} 1$ [Exercício: porquê?]. Mas também $000 < 1$ . De facto, $0^{n} < 1$ para qualquer $n > 0$ . Portanto, seguindo a ordem lexicográfica, há infinitas palavras entre $0$ e $1$ .

Esta conclusão, embora dramática, mostra que a ordem lexicográfica é inútil na importante tarefa de enumerar (isto é, listar) todas as palavras por ordem. Para resolver este problema é necessária mais uma ordem entre palavras:

Ordem Mista. Dadas duas palavras $p, q \in Σ^{*}$ , $p \leq_{M} q$ se $∣ p ∣ < ∣ q ∣$ ou ( $∣ p ∣ = ∣ q ∣$ e $p \leq_{L} q$ ).

Dito de outra forma, a ordem mista define o seguinte processo:

Primeiro, as palavras são agrupadas por comprimentos iguais: todas as palavras de comprimento 0 antes das de comprimento 1, todas as de comprimento 1 antes das de 2, etc.
Depois, em cada grupo, as palavras (todas com o mesmo comprimento) são ordenadas lexicograficamente.

Revisitando o exemplo anterior:

$0$ e $1$ têm o mesmo comprimento. Portanto, são comparadas lexicograficamente: $0 <_{M} 1$ porque $0 <_{L} 1$ .
O comprimento de $00$ é maior que o de $1$ . Portanto, $1 <_{M} 00$ .
$01$ e $10$ têm o mesmo comprimento. Lexicograficamente, $01 <_{L} 10$ portanto $01 <_{M} 10$ .

De facto a ordem mista é uma ferramenta essencial porque permite "avançar passo-a-passo" no conjunto de todas as palavras, sem deixar nenhuma de fora. Mais concretamente:

A ordem mista define uma sequência de todas as palavras. No caso do alfabeto binário, com $0 < 1$ :

$λ <_{M} 0 <_{M} 1 <_{M} 00 <_{M} 01 <_{M} 10 <_{M} 11 <_{M} 000 <_{M} \dots$

Sucessor

A ordem mista permite começar na primeira palavra, avançar para a seguinte, depois para a seguinte, etc. da mesma forma são contados os números: 0, 1, 2, etc.

A passagem de um número para o seguinte (x++) tem nome, sucessor, que também se aplica às palavras:

Sucessor. Seja $Σ = {a_{1} < a_{2} < \dots < a_{n}}$ um alfabeto ordenado. A função sucessor tem assinatura $σ : Σ^{*} \to Σ^{*}$ e calcula-se pelas seguintes regras:

base $σ (λ) = a_{1}$ .

passo Se $i < n$ então $σ (p a_{i}) = p a_{i + 1}$ . Caso contrário, $σ (p a_{n}) = σ (p) a_{1}$ .

Voltando ao exemplo anterior: $σ (λ) = 0, σ (0) = 1, σ (1) = σ (λ) 0 = 00, \dots$

Visto de outra forma, usando o sucessor obtém-se uma sequência que começa na palavra vazia e percorre todas as palavras:

$λ \to σ 0 \to σ 1 \to σ 00 \to σ \dots$

Há uma clara relação entre a ordem mista e a função sucessor.

Seja $p_{0} <_{M} p_{1} <_{M} p_{2} <_{M} \dots$ a sequência de todas as palavras de $Σ^{*}$ que se obtém com a ordem mista e $p \in Σ^{*}$ uma palavra qualquer.

$p <_{M} σ (p)$ .

Se $p \neq = λ$ então existe uma palavra $q \in Σ^{*}$ tal que $p = σ (q)$ .

$p_{i + 1} = σ (p_{i})$ .

O que este teorema afirma, especialmente na igualdade $p_{i + 1} = σ (p_{i})$ , é que a ordem mista e a função sucessor são aspetos diferentes da mesma enumeração das palavras.

Linguagens

Numa linguagem de programação nem todas as palavras possíveis correspondem a programas válidos. Por exemplo:

2 return) *
    : dobro def (x

é uma palavra que pode ser formada com o alfabeto do python, mas não é um programa.

É necessário, de alguma forma, distinguir as palavras que são "válidas" das outras que não o são. De novo, encontramos na matemática exatamente as ferramentas necessárias.

Linguagem. Uma linguagem é um conjunto de palavras sobre um certo alfabeto. Isto é, $A$ é uma linguagem sobre $Σ$ se $A \subseteq Σ^{*}$ .

Esta definição de linguagem parece dizer pouco, mas por enquanto serve exatamente para o que se pretende.

Por exemplo, se $Π$ for a linguagem dos programas python então $print (2 + 40) \in Π$ mas $+) 40print 2 (\neq \in Π$ .

Mais tarde será enunciado e tratado o Problema Principal de ALP:

Problema Principal de ALP (versão 0). Dada uma linguagem $A$ e uma palavra $p$ no mesmo alfabeto, determinar se $p \in A$ .

Entretanto, como uma linguagem é (apenas) um conjunto de palavras, tem um certo número de elementos, que pode ser infinito (quantos programas python existem?): Se $A$ for uma linguagem, $∣ A ∣$ representa o número de elementos de $A$ .

Outros exemplos de linguagens são:

binárias ${0, 1}$ , ${λ, 0, 00, 000, \dots}$ , etc.
As palavras do português, sobre o alfabeto romano. Por exemplo, a, aba, abade, etc. mas não aa, prof, tásse, xkcd, etc.
Os programas de uma linguagem de programação.
As frases do português, sobre o alfabeto formado pelas palavras do português. Por exemplo bom dia, a aula é longa, etc. mas não dia dia dia, aula a é longa, etc.

Muitas vezes é útil visualizar-se uma linguagem de forma a explorar a estrutura das suas palavras. Isso pode ser feito através de árvores:

Árvore de uma Linguagem. Seja $A \subseteq Σ^{*}$ uma linguagem sobre $Σ$ .

Os vértices (ou nós) da árvore de $A$ (ou diagrama de $A$ ) são palavras de $Σ^{*}$ e cada aresta (ou arco) tem um símbolo de $Σ$ . Além disso, todas as arestas são da seguinte forma: se $p \in Σ^{*}$ e $a \in Σ$ então $p \to a p a$ é uma aresta. A raíz da árvore é a palavra vazia.

Cada vértice é representado por um círculo com a respetiva palavra lá dentro. Uma palavra da linguagem $A$ é representada por um círculo duplo.

Por exemplo, $A = {01, 011, 11, 101} \subseteq {0, 1}^{*}$ tem a seguinte árvore (onde os vértices irrelevantes foram omitidos):

Árvore (parcial) de $A = {01, 011, 11, 101}$

As palavras de $A$ estão em círculos duplos.

Operações com Linguagens

Como conjuntos, as linguagens podem ser combinadas pelas operações comuns: união, intersecção, etc. Além disso, como os seus elementos são palavras, podem ser definidas operações adicionais, específicas das linguagens (concatenação, fecho, etc).

Operações com Linguagens. Sejam $A, B$ linguagens sobre $Σ$ . Estão definidas as seguintes operações de conjuntos:

união $A \cup B = {p : p \in A \lor p \in B}$ .

intersecção $A \cap B = {p : p \in A \land p \in B}$ .

subtração $A ∖ B = {p : p \in A \land p \neq \in B}$ .

complemento $\overline{A} = Σ^{*} ∖ A$ .

Adicionalmente, usando as operações de palavras:

concatenação $A B = {pq : p \in A \land q \in B}$ .

potências $A^{0} = {λ}, A^{1} = A, A^{2} = AA, \dots, A^{n + 1} = A A^{n}$ .

fechos $A^{*} = A^{0} \cup A^{1} \cup A^{2} \cup \dots, A^{+} = A A^{*}$ .

inversão $A^{R} = {p^{R} : p \in A}$ .

Alguns exemplos das operações específicas das linguagens: Sejam $A = {a, b, ac}, B = {λ, a, c}$ . Então:

$A B = {a, b, ac} {λ, a, c} = {a λ, aa, ac, b λ, ba, bc, ac λ, aca, acc} = {a, aa, ac, b, ba, bc, aca, acc}$ .
- As palavras de $A B$ foram formadas escolhendo primeiro uma palavra de $A$ e depois uma palavra de $B$ .
- A palavra $ac$ pode ser obtida de suas formas: $a \cdot c$ e $λ \cdot ac$ .
$B^{2} = BB = {λ, a, c} {λ, a, c} = {λ, a, c, aa, ac, ca, cc}$ .
$A^{0} = {λ}; A^{2} = {aa, ab, aac, ba, bb, bac, aca, acb, acac}, \dots$ .
$A^{R} = {a, b, ca}, B^{R} = {λ, a, c} = B$ .

Confusões com a palavra vazia, o conjunto vazio, etc.

A palavra vazia, $λ$ , não é um símbolo. Qualquer símbolo, como palavra, tem comprimento 1. A palavra vazia tem comprimento 0.

O conjunto vazio, $\emptyset$ , tem 0 elementos. Para tornar este facto mais explícito também se escreve $\emptyset = {}$ .

O conjunto ${λ}$ tem um elemento, $λ$ . Portanto, não é o conjunto vazio.

Exemplo. Aqui (e só no âmbito deste exemplo) estamos a distinguir explicitamente os símbolos usando plicas, como em 'a', e as palavras usando aspas, como em "ab".

O alfabeto {a, b} tem dois símbolos: 'a' e 'b'.
Uma palavra é uma (qualquer) sequência finita de símbolos.
- Por exemplo "abba", "baba", "aa", etc.
Todas as palavras de comprimento 2 são "aa", "ab", "ba", "bb".
Também poderíamos listar todas as palavras de comprimento 3 (num total de oito palavras), etc.
Todas as palavras de comprimento 1 são "a" e "b".
- Se quiséssemos ser terrivelmente rigorosos, teríamos de dizer que 'a' e "a" são diferentes porque 'a' é um símbolo e "a" é uma sequência de símbolos, tal como, por exemplo, o inteiro 1 é completamente diferente de [1], que é uma lista de inteiros.
- Raramente é necessário distinguir explicitamente os símbolos das palavras de comprimento um.
Só há uma palavra com comprimento zero. Como sequência, "" é a (única) com zero símbolos. Em vez de "" escreve-se λ (ou ε ou ϵ).
- λ não é um símbolo mas uma palavra. Escrita por extenso é "".
Usando a concatenação de palavras podemos escrever, por exemplo: "abba" = "ab" · "ba".
- Outras formas de obter "abba" são "abba" = "a" · "bba", "abba" = "abb" · "a", etc.
- Em particular também "abba" = "abba" · λ ou "abba" = λ · "abba" ou mesmo "abba" = λ · "a" · λ · "bba".
- Nestes exemplos o λ nunca aparece entre "..." pois isso é o equivalente a um erro sintático. Também não escrevemos 2 */ 3 quando fazemos contas...
Em geral não se escrevem os símbolos como 'a', as palavras como "abab" nem as concatenações como "aa" · "ba".
- Portanto, em vez de "abba" = λ · "a" · λ · "bba" o que escrevemos é simplesmente abba = λaλbba.
- Este abuso de notação pode facilitar a leitura errada de λ como um símbolo, à semelhança de a e b.

Linguagens e Expressões Regulares

Uma forma de especificação formal de linguagens.

Linguagens e Expressões Regulares
- Linguagens Regulares
- Expressões Regulares

Na secção anterior observou-se que para definir uma linguagem de programação o fecho, $Σ^{*}$ , não é adequado porque tem "demasiadas" palavras.

Mais precisamente, a situação é a seguinte:

Para definir uma linguagem de programação começa-se for escolher um certo alfabeto e, sobre esse alfabeto, define-se uma linguagem cujas palavras são exatamente os programas válidos da linguagem de programação.

O Problema Principal de ALP (versão 0) – Dada uma linguagem $A$ e uma palavra $p$ no mesmo alfabeto, determinar se $p \in A$ – não desenvolve condições para determinar $p \in A$ . É necessário um "sistema" que permita definir linguagens formais e que seja:

Computável: Existe um algoritmo que recebe como entrada uma palavra $p$ e ao fim de um número finito de passos produz uma resposta sim ou não conforme $p \in A$ ou não.
Eficiente: O número de passos referido no passo anterior não deve ser "muito maior" que o comprimento da palavra.
Adequado: Deve ser possível definir (os programas de) qualquer linguagem de programação.

Portanto:

Problema Principal de ALP (versão 1): Determinar um sistema computável e eficiente para determinar se $p \in A$ e que seja adequado (i.e., $A$ é uma linguagem de programação).

Linguagens Regulares

As operações entre linguagens (principalmente, a união, a concatenação e o fecho) permitem começar por linguagens muito simples e definir formalmente, rigorosamente, sem ambiguidades, linguagens mais complexas. Por exemplo, a partir do alfabeto binário ${0, 1}$ , a linguagem das palavras com um número par de $1$ é ${0, 11}^{*}$ .

O ênfase em "formal, rigoroso, não ambíguo" é necessário para resolver algoritmicamente o Problema Principal de ALP. Mais especificamente, pretende-se obter um programa que tem como entrada uma especificação formal de uma linguagem e que produz um segundo programa que tem como entrada uma palavra e que determina se essa palavra pertence, ou não, à linguagem dada ao primeiro programa. Isto é, pretende-se definir um programa Super tal que

Se e for uma especificação formal de uma linguagem de programação L: PL = Super(e).
Seja p uma palavra. PL(p) é verdade ou falso conforme p in L ou não.
Tanto Super quanto PL devem ser eficientes.

O Problema Principal de ALP, nas suas várias versões, trata de encontrar uma "especificação formal" adequada e obter os programas Super e PL. De facto, a resolução seguida em ALP até vai mais longe: A resposta a $p \in A$ é calculada de forma que quando $p$ for um programa válido (isto é, " $p \in A$ " é verdade) também se obtém uma "representação intermédia" de $p$ , apta a ser executada.

Por enquanto define-se a classe das linguagens regulares:

Linguagem Regular (LR). Seja $Σ$ um alfabeto. Uma linguagem regular sobre $Σ$ define-se recursivamente pelas seguintes regras:

base Os conjuntos $\emptyset, {λ}$ e, para cada $a \in Σ, {a}$ são linguagens regulares.

passo Se $A$ e $B$ forem linguagens regulares então $A \cup B, A B, A^{*}$ também são linguagens regulares.

fecho Um conjunto de palavras é uma linguagem regular se, e só se, pode ser definido através de um número finito de aplicações do passo a partir dos conjuntos da base.

Alguns exemplos de linguagens regulares:

${001, 110} = {0} {0} {1} \cup {1} {1} {0}$ .
Qualquer linguagem finita.
O conjunto das palavras que começam em $0$ é infinito mas regular: ${0} {0, 1}^{*}$ .

Expressões Regulares

A notação usual dos conjuntos, com ${}, ()$ , etc. torna difícil escrever e ler linguagens regulares. Para aliviar esse problema usa-se uma notação específica.

Expressão Regular (ER). Seja $Σ$ um alfabeto. Uma expressão regular sobre $Σ$ define-se recursivamente pelas seguintes regras:

base As expressões vazio $\emptyset$ , palavra vazia $λ$ e, para cada $a \in Σ, a$ são expressões regulares.

passo Se $a$ e $b$ forem expressões regulares então a união $a \cup b$ , a concatenação (ou produto) $a \cdot b$ e a iteração $a^{*}$ também são expressões regulares.

fecho Uma expressão é uma expressão regular se, e só se, pode ser definida através de um número finito de aplicações do passo a partir das expressões da base.

Alguns exemplos de expressões regulares:

$001 \cup 110 ≃ (0 \cdot (0 \cdot 1)) \cup ((1 \cdot 1) \cdot 0)$ .
Qualquer palavra de $Σ^{*}$ .
$0 \cdot (0 \cup 1)^{*}$ .

Antes de avançar no estudo das ER e LR é importante esclarecer o seguinte ponto importante sobre a notação das expressões regulares:

Regras de Simplificação das Expressões Regulares. A escrita completa de uma expressão regular pode (ainda) ser confusa, por causa dos parêntesis:

$(0^{*} \cup (1 \cdot 0 \cdot (0^{*}))) \cdot 1 \cdot (0^{*}) \cdot (((0 \cdot (1^{*}) \cup (1^{*}))))$

Para simplificar esta escrita usam-se as seguintes regras de simplificação:

Sempre que possível não se usa o símbolo da concatenação. Isto é, em vez de $x \cdot y$ escreve-se $x y$ .
A iteração $^{*}$ tem precedência sobre $\cdot$ e sobre $\cup$ . Isto é, $0 \cdot 1^{*}$ é $0 \cdot (1^{*})$ , não $(0 \cdot 1)^{*}$ . Igualmente, $0 \cup 1^{*}$ é $0 \cup (1^{*})$ , não $(0 \cup 1)^{*}$ .
A concatenação $\cdot$ tem precedência sobre a união $\cup$ . Isto é, $a \cup b \cdot c$ é $a \cup (b \cdot c)$ , não $(a \cup b) \cdot c$ .

Com estas regras a ER acima fica com o seguinte aspeto: $(0^{*} \cup 10 0^{*}) 1 0^{*} (0 1^{*} \cup 1^{*})$

Diagramas das Expressões Regulares

As expressões regulares podem ser representadas por um diagrama gráfico cuja visualização pode ajudar a entender a sua estrutura.

Diagrama de uma Expressão Regular (Diagrama de Wirth). O diagrama de uma expressão regular é um grafo orientado definido para as operações base e passo da seguinte forma:

Forma da Expressão Regular Tipo Sub-Grafo

$a$ símbolo ou $λ$

$x y$ concatenação

$x \cup y$ união

$x^{*}$ iteração

Forma da Expressão Regular	Tipo	Sub-Grafo
$a$	símbolo ou $λ$
$x y$	concatenação
$x \cup y$	união
$x^{*}$	iteração

Por exemplo, o diagrama da expressão regular $(11 \cup 0)^{*} (00 \cup 1)^{*}$ pode ser obtido da seguinte forma:

Operação	Diagrama
Início
Concatenação
Iterações
Uniões

No diagrama final há várias arestas que podem ser eliminadas e ainda continuar a representar a expressão regular inicial. Por exemplo, uma das duas arestas $λ$ consecutivas, no cento do diagrama, pode ser eliminada.

Operação	Diagrama
Simplificação

Neste caso foi simples detetar uma aresta que podia ser eliminada. Em geral, quais são as arestas que podem ser eliminadas?

Teorema da Eliminação de Arestas Vazias. A aresta pode ser eliminada se:

O vértice $α$ não é final e não saem mais arestas de $α$ ou

O vértice $β$ não é inicial e não entram mais arestas em $β$ .

Alternativamente, a aresta não pode ser eliminada se:

O vértice $α$ é final ou saem mais arestas de $α$ e

O vértice $β$ é inicial ou entram mais arestas em $β$ .

Usando o teorema da eliminação de arestas vazias:

Operação	Diagrama
Simplificação (II)

Semântica das Expressões Regulares

O número quatro pode ser referido de várias formas: IV, 100, 4, quatro, 2+2, etc. Todas essas formas são expressões – texto, sintaxe – cuja interpretação – significado, semântica – é um certo objeto abstrato.

Esta é também a relação entre as linguagens regulares e as expressões regulares: As linguagens são conjuntos (objetos matemáticos, abstratos) que podem ser representados por certas expressões. Isto é, a semântica das ER são as LR. Reciprocamente, as ER são uma sintaxe para as LR. Mais precisamente:

Linguagem Representada por uma Expressão Regular. Qualquer expressão regular sobre $Σ$ representa uma certa linguagem, definida pelas seguintes regras:

$L (\emptyset) = \emptyset$ .

$L (λ) = {λ}$ .

Para cada $a \in Σ, L (a) = {a}$ .

Se $x$ for uma expressão regular então $L (x^{*}) = L (x)^{*}$ .

Se $x, y$ forem expressões regulares então $L (x \cup y) = L (x) \cup L (y)$ .

Se $x, y$ forem expressões regulares então $L (x y) = L (x) L (y)$ .

Até aqui, e neste enunciado em particular, estão a ser usados os mesmos símbolos (sintaxe), por exemplo $\emptyset, \cup,^{*}$ com significados (semântica) muito diferentes. Por exemplo, " $\cup$ " numa ER é apenas um símbolo que liga outras ERs — da mesma forma que + liga \quaddois números\quad duas expressões numéricas. Mas " $\cup$ " numa LR é uma operação entre conjuntos, que tem um valor bem definido — tal como 2 + 2 tem um valor bem definido (sob as convenções comuns).

Além disso, foi apenas definida uma função entre ERs e certos conjuntos de palavras – nada afirma, até aqui, que $L (x)$ é regular. Isto é, se $x$ for uma expressão regular então $L (x)$ é uma linguagem. A relação com as linguagens regulares fica esclarecida a seguir:

Equivalência de Expressões e Linguagens Regulares.

Cada expressão regular representa uma linguagem regular. Mais especificamente: Se $x$ for uma expressão regular sobre $Σ$ então $L (x)$ é uma linguagem regular sobre $Σ$ .

Cada linguagem regular pode ser representada por uma expressão regular. Mais especificamente: Se $A$ for uma linguagem regular sobre $Σ$ então existe uma expressão regular sobre $Σ$ , $x$ , tal que $A = L (x)$ .

Isto é, as expressões regulares denotam exatamente as linguagens regulares e a relação entre umas e outras é a função $L$ . Dito de outra forma, as LR são a semântica associada às ER e, reciprocamente, as ER proporcionam uma sintaxe para as LR.

Por exemplo, a linguagem dos inteiros sem sinal e sem $0$ à esquerda (isto é, a representação binária dos números inteiros positivos):

${0, 1, 10, 11, 100, 101, \dots} = {0} \cup {1} {λ, 0, 1, 00, 01, \dots} = {0} \cup {1} {0, 1}^{*} = L (0 \cup 1 (0 \cup 1)^{*})$

Há ainda outro tipo importante de equivalência: Depois de fixado o conjunto de símbolos e de operações, duas expressões (sintaxes) muito diferentes podem ter o mesmo valor (semântica).

Por exemplo o número quatro (o objeto matemático abstrato) pode ser representado pelas expressões $4$ , $2 + 2$ , $2^{2}$ , etc. Nestes casos escreve-se $2 + 2 = 4$ , $2^{2} = 4$ etc. Mas em ALP é preciso cuidado com o sinal " $=$ ". As expressões " $4$ " e " $2 + 2$ " são sintaticamente diferentes (por exemplo, porque " $4$ " tem apenas um símbolo e " $2 + 2$ " tem três) mas equivalentes (a mesma semântica).

Nas linguagens regulares " $A = B$ " representa a igualdade entre conjuntos, uma relação matemática. No caso das expressões regulares é necessário esclarecer se se trata de igualdade sintática ou de uma equivalência (isto é, uma igualdade semântica). Por exemplo, $0 \cup 1$ e $1 \cup 0$ são diferentes ao nível sintático: diferem logo no primeiro símbolo. Mas ambas representam a mesma linguagem regular, o conjunto ${0, 1}$ . Isto é, $L (0 \cup 1) = L (1 \cup 0)$ .

Equivalência de Expressões Regulares. Duas expressões regulares, $x, y$ , sobre $Σ$ são equivalentes, $x \equiv y$ , se $L (x) = L (y)$ .

No uso comum de expressões regulares pretende-se usar a equivalência, não a igualdade sintática, pelo que " $x = y$ " normalmente representa a equivalência, apesar de esta escrita ser um abuso da notação. Isto é, escreve-se $0 \cup 1 = 1 \cup 0$ em vez de $0 \cup 1 \equiv 1 \cup 0$ , porque é mais conveniente. Os casos em que se trata a igualdade sintática devem ser explicitamente assinalados como tais.

Propriedades das Expressões Regulares

Sejam $x, y, z$ expressões regulares sobre o alfabeto $Σ$ . Considerando as operações de união e concatenação:

$x \cup (y \cup z) x \cup \emptyset x \cup y x \cup x x (y \cup x) = (x \cup y) \cup z = \emptyset \cup x = x = y \cup x = x = x y \cup x z x (yz) x λ x \emptyset (x \cup y) z = (x y) z = λ x = x = \emptyset x = \emptyset = x z \cup yz$

Para o fecho:

$\emptyset^{*} (x^{*})^{*} x (y x)^{*} (x \cup y)^{*} = λ = x^{*} = (x y)^{*} x = (x^{*} \cup y)^{*} = x^{*} (x \cup y)^{*} = (x \cup y x^{*})^{*} = (x^{*} y^{*})^{*} = (x^{*} y)^{*} x^{*} = x^{*} (y x^{*})^{*} λ^{*} x^{*} = λ = λ \cup x x^{*}$

Com estas equivalências uma ER inicialmente complicada (isto é, comprida e/ou profunda) pode ser simplificada. Um exemplo imediato é $((a^{*})^{*})^{*} = a^{*}$ . Outro exemplo:

$a^{*} (b \cup (a^{*} b^{*})^{*}) a a^{*} (b a^{*})^{*} b = ? (a \cup b)^{*} a (a \cup b)^{*} b$

Aplicando as regras de equivalência $a^{*} (b \cup (a^{*} b^{*})^{*}) a a^{*} (b a^{*})^{*} b = = a^{*} (b \cup (a \cup b)^{*}) a a^{*} (b a^{*})^{*} b = a^{*} (a \cup b)^{*} a a^{*} (b a^{*})^{*} b = (a \cup b)^{*} a a^{*} (b a^{*})^{*} b = (a \cup b)^{*} a (a \cup b)^{*} b = ? b^{*} a (b \cup a)^{*} b (x^{*} y^{*})^{*} = (x \cup y)^{*} y \cup (x \cup y)^{*} = (x \cup y)^{*} (porqu \overset{e}{ˆ} ?) x^{*} (x \cup y)^{*} = (x \cup y)^{*} x^{*} (y x^{*})^{*} = (x \cup y)^{*} aceit \overset{a}{ˊ} vel... continuando:$

$= (a \cup b)^{*} a (a \cup b)^{*} b = (b \cup a)^{*} a (a \cup b)^{*} b = b^{*} (a b^{*})^{*} a (a \cup b)^{*} b = b^{*} a (b^{*} a)^{*} (a \cup b)^{*} b = b^{*} a (b^{*} a)^{*} (b \cup a)^{*} b = b^{*} a (b^{*} a)^{*} (b^{*} a)^{*} b^{*} b = b^{*} a (b^{*} a)^{*} b^{*} b = b^{*} a (b \cup a)^{*} b x \cup y = y \cup x (x \cup y)^{*} = x^{*} (y x^{*})^{*} (x y)^{*} x = x (y x)^{*} x \cup y = y \cup x (x \cup y)^{*} = (x^{*} y)^{*} x^{*} x^{*} x^{*} = x^{*} (porqu \overset{e}{ˆ} ?) (x^{*} y)^{*} x^{*} = (x \cup y)^{*}$

As linguagens e expressões regulares são o passo atual para resolver o Problema Principal de ALP (versão 1) – Determinar um sistema computável, eficiente e adequado para definir linguagens de programação.

Nesse sentido importa responder às seguintes questões:

Dada uma linguagem regular $A$ , como obter um sistema computável e eficiente para determinar se $p \in A$ ?

As linguagens regulares são adequadas para definir todas as linguagens de programação? Por exemplo, será possível definir a sintaxe dos programas Python ou Java usando apenas expressões regulares?

Estas questões são resolvidas no próximo capítulo, Autómatos Finitos, onde é definido e estudado um modelo abstrato de computador simples e como este se relaciona com as ER e LR.

Palavras, Linguagens e Expressões Regulares — Exercícios

Otimização Prematura

O xkcd obrigatório.

Indicações gerais para os exercícios de implementação

Quase todos os exercícios de implementação descrevem uma função ou estrutura de dados sujeita a algumas condições. É da sua responsabilidade testar os casos suficientes para assegurar o comportamento esperado.

A linguagem de programação que usar é indiferente, desde que não dê tiros nos pés com opções aberrantes tipo "C" ou "COBOL". Ou "JavaScript". Principalmente "JavaScript".

Também não é fundamental a maneira como organiza o código, seja em classes ou de outra forma, desde que o organize logicamente.

Mais alguns princípios gerais importantes:

Os atributos das estruturas devem ter permissões tão restritas quanto possível. Se não for necessário alterar um atributo, não o permita. Se o atributo não tem de ser lido, esconda-o.

DRY, Don't Repeat Yourself, Não se repita. Se está a escrever código repetido está a fazer um disparate. Grande. Pare imediatamente e pense como vai evitar as repetições repetições.

Premature optimization is the root of all evil, A otimização prematura é a raiz de todos os males. O seu código pode ser sempre melhorado: mais rápido, mais geral, mais específico, mais isto e aquilo. Se a melhoria não for necessária não perca tempo com ela.

Use as ferramentas e adquira os conhecimentos do Engenheiro Informático que vai ser:

Escolha e use ferramentas com boas comunidades e suporte. Torne-se fluente no seu ambiente de trabalho, na linha de comandos, no editor/ide, a usar repositórios, debuggers, testes, linters, profilers, etc.

Se ainda não o fez, instale um sistema operativo no seu computador. Infelizmente, em geral, os computadores quando vêm da loja trazem instalada uma coisa que mal serve para utilizadores amadores. Instale e use um sistema operativo baseado em unix, como o linux, o bsd ou o macos.

Este curso é de Engenharia Informática. Não permita que se confunda com uma qualquer "furmassão avançada de web-bonecos e insta-qualquer-coisa" daquelas que abundam nos motores de pesquisa — basicamente porque GIGO: Garbage In, Garbage Out.

Invista tempo e esforço a identificar, compreender e resolver as dificuldades. Procure as melhores referências, fale com colegas e com professores — nada com valor é rápido ou fácil.

Os exercícios assinalados com "✓" serão resolvidos nas aulas práticas; Os assinalados com "†" têm elevada dificuldade. Todos os restantes devem ser resolvidos pelos alunos.

Palavras, Linguagens e Expressões Regulares — Exercícios

Alfabetos, Palavras e Linguagens

Exercício 01

Defina alfabetos para:
1. Escrever os números naturais $0, 1, 2, \dots$ em notação hexadecimal.
2. Representar a configuração de um semáforo, no que diz respeito aos automóveis.
3. Escrever as palavras da língua portuguesa.
4. Escrever frases em português.
Seja $Σ = {0, 1, 2}$ um alfabeto, $u = 012$ e $v = 22021$ palavras sobre $Σ$ . Escreva por extenso as seguintes palavras:
1. $uv$
2. $vu$
3. $v^{R}$
4. $u^{3}$
5. $01 2^{3}$
6. $(012)^{3}$
7. $v^{0} u$
8. $(v^{2})^{R}$

Exercício 02

Liste todas as sub-palavras, todos o prefixos e todos os sufixos das seguintes palavras sobre o alfabeto $Σ = {0, 1, 2, 3}$ :

$01023$
$11111$
$λ$

Exercício 03

Seja $Σ = {a, b}$ . Construa definições recursivas dos seguintes conjuntos:

$C_{1} = {palavras sobre Σ tais que o s \overset{ı}{ˊ} mbolo a ocorre aos pares}$ . $C_{1}$ inclui, por exemplo, $bbaab$ e $aaaa$ mas não inclui $aaa$ nem $aabaaaba$ .
$C_{2} = {p \in Σ^{*} : ∣ p ∣ \overset{e}{ˊ} par, p come \overset{c}{¸} a por a e, em p, os a e os b ocorrem alternados}$ .
$C_{3} = {p \in Σ^{*} : p \overset{e}{ˊ} capicua}$ .
✓ $C_{4} = {a^{n} b^{n} \in Σ^{*} : n > 0}$ .
$C_{5} = {a^{i} b^{j} \in Σ^{*} : 0 \leq i < j}$ .
✓ $C_{6} = {p \in Σ^{*} : ∣ p ∣_{a} = ∣ p ∣_{b}}$ . Sugestão: Use a concatenação no passo recursivo.

Exercício 04

Encontre a menor palavra sobre o alfabeto $Σ = {0}$ que não está em ${λ, 0, 0^{2}, 0^{5}}^{3}$ .

Exercício 05

† Demonstre as propriedades do fecho de linguagens.
† Demonstre as propriedades da concatenação de expressões regulares.

Exercício 06

Na ordem lexicográfica, quantas palavras estão entre $0$ e $1$ ? E na ordem mista?

Exercício 07

Desenhe os diagramas das seguintes linguagens:

${0^{n} : n \overset{e}{ˊ} par}$ .
${p \in {0, 1}^{*} : ∣ p ∣ \leq 4}$ .
${0^{n} 1^{n} : n \geq 0}$ .
${0^{n} 1^{m} : n, m \geq 0}$ .

Exercício 08

Descreva recursivamente o conjunto das palavras sobre o alfabeto ${a, b}$ ...

com número par de símbolos.
com número par de ocorrências de $a$ .
com número par de ocorrências de $a$ e número ímpar de ocorrências de $b$ .
com número ímpar de símbolos ou com menos de $n$ símbolos.
com número ímpar de símbolos ou com, pelo menos, $n$ símbolos.
com número ímpar de símbolos e com menos de $n$ símbolos.
com número ímpar de símbolos e com, pelo menos, $n$ símbolos.
de comprimento menor do que $n$ e com numero par de ocorrências de $b$ .
formadas por um certo número de $a$ , seguido de um único $b$ , seguido do mesmo número de $a$ .

Exercício 09

Calcule ${0, 1} {1, 2}$ e compare com ${1, 2} {0, 1}$ . Enuncie o que observou como uma propriedade geral das operações de linguagens.
É verdade que $∣ A B ∣ = ∣ A ∣ ∣ B ∣$ ?
Sejam $A = {(01)^{n} : n \geq 0}$ e $B = {01, 010}$ . Calcule $A B$ e $A B A$ .
Verifique que ${0, 10}^{*}$ é a linguagem das palavras binárias que não têm $11$ como subpalavra e que terminam em $0$ .
† Confirme que $A^{+} = A^{*}$ se e só se $λ \in A$ .
† Confirme que $(A B)^{R} = B^{R} A^{R}$ e que $(A \cup B)^{R} = A^{R} \cup B^{R}$ .

Exercício 10

Mostre que, se $A, B$ forem linguagens então $(A \cup B)^{*} = A^{*} (B A^{*})^{*}$ .

Lembre-se que para provar que dois conjuntos $X, Y$ são iguais tem de provar as duas inclusões $X \subseteq Y$ e $Y \subseteq X$ .

Exercício 11

Sejam $A = {anti, pro, λ}, B = {pesso, soci}, C = {al}$ . O que são $A BC$ e $A^{*} BC$ ?

Exercício 12

† Seja $A$ uma linguagem sobre ${0, 1}$ e $p \in {0, 1}^{*}$ . Encontre condições necessária e suficientes para que se verifique $A^{*} ∖ {x} = A^{+}$ .

Exercício 13

Verifique, com demonstrações ou contra-exemplos, quais das seguintes igualdades são válidas para todas as linguagens:

$A^{R}^{*} = (A^{*})^{R}$ .
$(A^{+})^{*} = A^{*}$ .
$(A \cup A^{R})^{*} = A^{*} \cup (A^{*})^{R}$ .
$A^{2} \cup B^{2} = (A \cup B)^{2}$ .
$A^{*} \cap B^{*} = (A \cap B)^{*}$ .

Exercício 14

Mostre que para $n \geq 1$ :

$⋃_{i = 0}^{n} A^{i} = ({λ} \cup A)^{n}$ .
$(A^{*})^{n} = A^{*}$ .
Se $λ \neq \in A$ então $(A^{+}) = A^{n} A^{*}$ .

Exercício 15

Demonstre as seguintes igualdades:

$A (B A)^{*} = (A B)^{*} A$ .
$(A \cup B)^{*} = (A^{*} B^{*})^{*}$ .
$A (B \cup C) = A B \cup A C$ .
$(A \cup B) C = A C \cup BC$ .
$A^{*} B (D A^{*} B \cup C)^{*} = (A \cup B C^{*} D)^{*} B C^{*}$ .

Expressões Regulares

Exercício 16

✓ Considere a expressão regular $(11 \cup 0)^{*} (00 \cup 1)^{*}$ e o respetivo diagrama.

Encontre uma palavra incompatível com esta expressão regular.
O que acontece se remover a aresta $λ$ central do diagrama simplificado?

Exercício 17

Desenhe e simplifique o diagrama de $a^{*} b (c \cup d a^{*})^{*}$ .
Encontre a mais curta palavra não vazia das linguagens das seguintes expressões:
1. $10 \cup (0 \cup 11) 0^{*} 1$ .
2. $(00 \cup 11 \cup (01 \cup 10) (00 \cup 11)^{*} (01 \cup 10))^{*}$ .
3. $((00 \cup 11)^{*} \cup (001 \cup 110)^{*})^{*}$ .
Defina informalmente um algoritmo para encontrar a menor palavra numa linguagem regular definida por:
1. Uma expressão regular.
2. O diagrama de uma expressão regular.

Exercício 18

Desenhe os diagramas das seguintes expressões regulares:
1. $(00 \cup 10) (101)^{*} \cup 01$ .
2. $((00 \cup 11)^{*} \cup (001 \cup 110)^{*})^{*}$ .
3. $(a \cup b c^{*} d)^{*} b c^{*}$ .
Determine as expressões regulares definidas pelos seguintes diagramas:
Determine o menor diagrama que representa $λ$ .
Encontre exemplos que mostram a necessidade de cada uma das condições do teorema da remoção das arestas $λ$ .

Exercício 19

Construa uma expressão regular para representar os números reais sem sinal, de acordo com as seguintes regras:

Um número real tem sempre uma vírgula decimal.
Um número real começa por 0 se e só se a sua parte inteira é 0.
Um número real termina em 0 se e só se a sua parte decimal é 0.

Exercício 20

Encontre expressões regulares para representar as seguintes linguagens:

✓ A linguagem das palavras sobre ${a, b, c}$ em que todos os $a$ 's precedem todos os $b$ 's que, por sua vez, precedem todos os $c$ 's (donde que todos os $a$ 's precedem todos os $c$ 's), podendo não haver nem $a$ 's, nem $b$ 's, nem $c$ 's.
✓ A linguagem da alínea anterior sem a palavra vazia.
As palavras sobre ${a, b, c}$ de comprimento inferior a 3.
As palavras sobre ${a, b, c}$ que começam por $a$ , acabam em $cc$ e têm exatamente dois $b$ 's.
A linguagem das palavras sobre ${a, b}$ que têm $aa$ e $bb$ como subpalavras.
As palavras sobre ${a, b}$ de que $bba$ não é subpalavra.
✓ A linguagem das palavras sobre ${a, b}$ que não têm prefixo $aaa$ .
✓ A linguagem das palavras sobre ${a, b}$ que não têm $aaa$ como subpalavra.
As palavras sobre ${a, b}$ em que $ab$ não ocorre.
As palavras sobre ${a, b}$ em que $ab$ ocorre.
As palavras sobre ${a, b}$ em que $ab$ ocorre só uma vez.

Exercício 21

Descreva informalmente as linguagens representadas pelas seguintes expressões regulares:

$(a \cup b \cup c) (a \cup b \cup c)^{*}$ .
$(a \cup b) ((a \cup b) (b \cup a))^{*}$ .
$5 \cup (1 \cup 2 \cup \dots \cup 9) (0 \cup 1 \cup \dots \cup 9)^{*} (0 \cup 5)$ .
$c^{*} (a \cup b) (a \cup b \cup c)^{*}$ .
$(a (b \cup c)^{*} a \cup b \cup c)^{*}$ .

Exercício 22

Simplifique as seguintes expressões regulares:

✓ $\emptyset^{*} \cup a^{*} \cup b^{*} (a \cup b)^{*}$
$a a^{*} b \cup b$
✓ $b^{*} (a \cup (b^{*} a^{*})^{*}) a b^{*} (a b^{*})^{*} b$
† $(a^{*} b)^{*} \cup (b^{*} a)^{*}$

Exercício 23

Encontre uma expressão regular para as seguintes linguagens binárias:

Que representam as potências de $4$ .
Com, pelo menos, uma ocorrência de $001$ .
† Que não têm $001$ como subpalavra.
Com, quanto muito, uma ocorrência de $00$ e, quanto muito, uma ocorrência de $11$ .
Em que nenhum prefixo tem mais dois $0$ s que $1$ s nem mais dois $1$ s que $0$ s.

Exercício 24

Verifique as igualdades $0^{*} (0 \cup 1)^{*} (10)^{+} (0^{*} 1^{*} \cup 0^{*}) = (0 \cup 10^{*})^{*} = (10)^{*} 1 0^{+} 1^{*}$

Exercício 25

Descreva em linguagem natural as linguagens das seguintes expressões regulares:
1. $(0^{*} 1^{*})^{*} 0$ .
2. $(01^{*})^{*} 0$ .
3. $(00 \cup 11 \cup (01 \cup 10) (00 \cup 11)^{*} (01 \cup 10))^{*}$ .
4. $0^{*} \cup (0^{*} 1 \cup 0^{*} 11) (0^{+} 1 \cup 0^{+} 11)^{*} 0^{*}$ .
Simplifique as seguintes expressões regulares:
1. $(00)^{*} 0 \cup (0 0^{*})$ .
2. $(0 \cup 1) (λ \cup 00)^{+} \cup (0 \cup 1)$ .
3. $(0 \cup λ) 0^{*} 1$ .
Mostre que $(0^{2} \cup 0^{3})^{*} = (0^{2} 0^{*})^{*}$ .

Exercício 26

Defina expressões regulares para as linguagens binárias das palavras que:

O quinto símbolo a contar da direita é $0$ .
Têm $000$ ou $111$ como subpalavra.
Não têm $000$ nem $111$ como subpalavra.
Não têm $010$ como subpalavra.
Têm um número ímpar de $0$ s.
Têm um número par de ocorrências de $011$ .

Exercício 27

Defina uma ER para as datas de acordo com a Norma ISO 8601. Considere só o caso YYYY-MM-DD:

Permita que sejam representadas datas incorretas, como 2014-34-96.
Restrinja os valores para os meses e para os dias, mas permita ainda dias inconsistentes com o mês. Por exemplo, 2014-02-31.
Restrinja os valores para os dias de forma a serem consistentes com o mês, mas ignore o anos bissextos (isto é, assuma que fevereiro tem sempre 28 dias). Por exemplo 2004-02-29 não é válida.
Trate dos anos bissextos.

Um ano bissexto é um ano múltiplo de 4 (por exemplo, 1948 é bissexto), exceto se também é múltiplo de 100 (por exemplo, 1900 não é bissexto) mas os múltiplos de 400 são sempre bissextos (por exemplo, 1600 é bissexto).

Implementação

Programa 00

Escreva uma função, listWords(fileName) que lê o ficheiro de texto fileName e produz a lista de palavras que ocorrem (sequencialmente) nesse ficheiro. Descarte os símbolos de pontuação e converta as letras para minúsculas. Sugestão: consulte a documentação de str e de string do python.

Programa 01

Escreva uma função, symbolsIn(word), que tem como entrada uma string e que devolve uma lista de símbolos. Assuma que, por omissão, os símbolos da string são separados por underscore (_) mas, opcionalmente, a função tem o argumento sep para usar um separador alternativo.

Entrada	Resultado
`"a_b_color_b_a"`	`["a", "b", "color", "b", "a"]`
`"single"`	`["single"]`
`""`	`[""]`
`"_"`	`["", ""]`

Programa 02

Escreva uma função, alphabetFor(word), que tem como argumento uma string e que devolve o menor alfabeto para gerar essa palavra. Assuma que, por omissão, os símbolos da string são separados por underscore (_) mas, opcionalmente, a função tem o argumento sep para usar um separador alternativo.

Note bem que no resultado não devem aparecer elementos repetidos.

Entrada	Resultado (`sep="_"`)	Resultado (`sep=""`)
`"a_b_color_b_a"`	`["a", "b", "color"]`	`["a", "_", "b", "c", "o", "l", "r"]`
`"single"`	`["single"]`	`["s", "i", "g", "l", "e"]`
`""`	`[]`	`[]`
`"_"`	`[]`	`["_"]`

Programa 03

Escreva uma função, generated(word, alphabet), em que word é uma string e alphabet uma lista de string e que determina se os símbolos de word estão todos em word (isto é, o resultado é booleano). Assuma que, por omissão, os símbolos da string são separados por underscore (_) mas, opcionalmente, a função tem o argumento sep para usar um separador alternativo.

Entrada `word`	Entrada `alphabet`	Resultado
`"a_b_color_b_a"`	`["a", "b", "color"]`	`true`
`"single"`	`["single"]`	`true`
`""`	`[]`	`true`

Programa 04

Use uma biblioteca de expressões regulares (do python3, por exemplo) e escreva expressões para reconhecer palavras que:

Começam pela letra a; Não começam pela letra a; Terminam na letra a; Não terminam na letra a.
Têm pelo menos uma ocorrência de a; Não têm ocorrências de a; O número de ocorrências de a não é 1; O número de ocorrências de a é exatamente 1.
Têm um a ou um b; Têm um a e um b; Têm um a e, mais à frente, um b.
Se têm um a então também têm um b; Se têm um a então também têm um b que ocorre antes do a; Se têm um a então também têm um b que ocorre depois do a; Se têm um a então não têm um b.

O pressuposto geral nas bibliotecas de ER é que vai ser feita uma pesquisa de subpalavras. Isto é, a ER é usada como um padrão que vai "percorrer" uma palavra "maior" para detetar subpalavras compatíveis com a ER dada.

Não é esse o pressuposto neste capítulo, onde as ER definem "palavras inteiras".

Programa 05

Escreva uma função countRE(expr, words) em que expr é uma das funções acima e words uma lista de string e que devolve o número de palavras em words aceites pela ER de expr.
Repita este exercício para a função filterRE(expr, words) que devolve a lista das palavras em words aceites por expr. Re-escreva countRE = len(filterRE).
Escreva o predicado allRE(expr, words) para testar se todas as palavras de words são aceites por expr. O mesmo para anyRE(expr, words) para testar se alguma palavra é aceite.

Programa 06

Use os comandos grep para substituir a função filter acima e wc para substituir len.
Aplique os filtros e contagens às palavras portuguesas com as ER dos exercícios anteriores.
Quantas palavras têm cal depois de um v sem que ocorra um o no meio? Quais estão em comum com british_english?

Na linha de comandos, em geral, tem a seguinte documentação sobre cada comando, aqui ilustrado com grep:

grep -h ou grep --help, um resumo curto das principais operações.

man grep, uma "página" com uma descrição curta do comando e uma lista das operações (a.k.a cheat sheet).

info grep, um "livro" com a descrição completa do comando e operações.

Programa 07

Se observar as contagens de palavras portuguesas (no ficheiro portuguese):

Há 431114 palavras.
Das quais 355762 com a letra a
E 75352 em que a não ocorre.

Use o grep e o wc para obter exatamente estes três números.

Autómatos Finitos

No capítulo anterior definiram-se as linguagens e expressões regulares com vista a resolver o Problema Principal de ALP (versão 1) – Determinar um sistema computável, eficiente e adequado para definir linguagens de programação. – onde:

Computável: Existe um algoritmo que recebe como entrada uma palavra $p$ e ao fim de um número finito de passos produz uma resposta sim ou não conforme $p \in A$ ou não.
Eficiente: O número de passos referido no passo anterior não deve ser "muito maior" que o comprimento da palavra.
Adequado: Deve ser possível definir (os programas de) qualquer linguagem de programação.

As linguagens regulares são uma classe de linguagens formais. Será que resolvem o Problema Principal de ALP? É necessário esclarecer:

Como definir um algoritmo, Super, que dada uma ER e produza um programa PL = Super(e) tal que, para cada palavra p, o resultado PL(p) é sim ou não conforme p in L(e) ou não?
Se as computações Super(e) e PL(p) são eficientes?
Se as linguagens regulares são adequadas para definir (os programs de) qualquer linguagem de programação?

O programa Super tem como entrada uma ER e, que especifica uma certa linguagem regular, e devolve um programa PL, que reconhece as palavras da linguagem definida por e.

Isto é semelhante ao trabalho de um compilador. Por exemplo, javac é um programa que tem como entrada ficheiros que especificam um certo programa e devolve esse programa em bytecode.

Autómatos Finitos Deterministas

Um modelo computacional simples, com memória limitada.

Autómatos Finitos Deterministas

Introdução

Exemplo de um Autómato Finito

O que acontece quando a entrada é $a^{*}$ ?

Para resolver o Problema Principal de ALP é necessário formalizar a noção de "computador/programa", de forma a representar PL = Super(e).

Os Autómatos Finitos são modelos formais de "computadores/programas" simples de descrever mas capazes de resolver vários problemas teóricos e com algumas aplicações práticas (ver o artigo na wikipedia).

Um autómato tem como entrada uma palavra que é processada símbolo a símbolo até que termina num certo estado. Em certos estados do autómato a palavra, depois de completamente "lida", é aceite e noutros é rejeitada.

Um autómato pode ser representado por um grafo orientado. Os vértices "são" os estados do autómato e as "arestas" indicam como são "lidos" os símbolos.

Autómato Finito Determinista

Autómato Finito Determinista (AFD). Um Autómato Finito Determinista (AFD) ou Autómato de Estados Finitos (Em inglês: Determinist Finite State Machine (DFSM) ou Determinist Finite State Automaton (DFSA)) é um tuplo $(Q, Σ, δ, q_{I}, F)$ onde:

Estados de Controlo $Q$ é um conjunto finito.

Alfabeto de Entrada $Σ$ é um alfabeto.

Transição $δ : Q \times Σ \to Q$ é uma função.

Estado Inicial $q_{I} \in Q$ .

Estados Finais ou de Aceitação $F \subseteq Q$ .

Intuitivamente, um AFD "anda" de estado em estado, conforme "processa" os símbolos de uma palavra, de acordo com a transição. Esse "passeio" começa no estado inicial e "consome" um símbolo da palavra de cada vez. Quando todos os símbolos estão processados, o AFD fica num certo estado. Se for um dos estados finais a palavra é aceite, caso contrário é rejeitada.

Por exemplo, seja $A = ({q_{0}, q_{1}, q_{2}, q_{3}}, {0, 1}, δ, q_{0}, {q_{1}, q_{2}})$ em que a transição $δ$ é definida pela seguinte tabela: $δ q_{0} q_{1} q_{2} q_{3} 0 q_{1} q_{2} q_{2} q_{3} 1 q_{2} q_{3} q_{2} q_{3}$

Os estados de controlo são os elementos de $Q = {q_{0}, q_{1}, q_{2}, q_{3}}$ .
O alfabeto de entrada é $Σ = {0, 1}$ .
A transição é a função $δ (q, s) = q^{'}$ em que $q^{'}$ está na linha $q$ e coluna $s$ da tabela acima.
O estado inicial é $q_{I} = q_{0}$ .
Os estados finais são os elementos de $F = {q_{1}, q_{2}}$ .

A função de transição de um AFD é quase sempre representada por uma tabela como no exemplo acima. Mas por vezes é conveniente apresentá-la como um conjunto de triplos: ${(i, a, j) : j = δ (i, a), i \in Q, a \in Σ} .$

A transição acima como um conjunto de triplos fica: ${(q_{0}, 0, q_{1}), (q_{0}, 1, q_{2}), (q_{1}, 0, q_{2}), (q_{1}, 1, q_{3}), \dots}$

Configuração, Computação, Aceitação

A computação da palavra $p = 000$ por este autómato é a sequência $q_{0} ⊢ 0 q_{1} ⊢ 0 q_{2} ⊢ 0 q_{2} \in F .$

A notação $q ⊢ a q^{'}$ indica que o autómato passa do estado $q$ para $q^{'}$ lendo o símbolo $a$ . Concatenado todos esses símbolos, da esquerda para a direita, obtém-se a palavra processada, neste caso $p = 000$ . Também é indicado que o último estado é final, pelo que a palavra $p$ é aceite pelo autómato $A$ .

Configuração. Computação. Palavra Aceite. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFD.

Uma configuração de $A$ é um par $(q, s) \in Q \times Σ^{*}$ onde $q$ é o estado atual e $s$ é o sufixo restante.

A computação da palavra $p = a_{1} a_{2} \dots a_{n} \in Σ^{*}$ pelo AFD $A$ é a sequência de configurações $(q_{0}, a_{1} a_{2} \dots a_{n}) ⊢_{A} (q_{1}, a_{2} \dots a_{n}) ⊢_{A} \dots ⊢_{A} (q_{n}, λ)$ em que:

base (configuração inicial) $q_{0} = q_{I}$ .

passo (processamento do símbolo ativo) $q_{i} = δ (q_{i - 1}, a_{i}), i \geq 1$ .

Se $q_{n} \in F$ a palavra $p$ é aceite pelo autómato $A$ . Caso contrário, $p$ é rejeitada por $A$ .

Por exemplo, aplicando estas definições ao autómato anterior:

De acordo com a base, a configuração inicial é $(q_{0}, \underline{0} 00)$ . O "símbolo ativo" está sublinhado.
Aplicando o passo obtém-se a configuração $(q_{1}, \underline{0} 0)$ porque $q_{1} = δ (q_{0}, 0)$ .
O passo é repetidamente aplicado, consumindo o símbolo ativo de cada vez, até que o sufixo restante é $λ$ :
1. $(q_{1}, \underline{0} 0) ⊢ (q_{2}, \underline{0})$ .
2. $(q_{2}, \underline{0}) ⊢ (q_{2}, λ)$ .

A computação pode ser visualizada numa tabela, com uma configuração por linha

$q q_{0} q_{1} q_{2} q_{2} s 000000 λ$ ou de forma ainda mais compacta: $q_{0} 000 q_{1} 00 q_{2} 0 q_{2} λ$ ou ainda $q_{0} ⊢ 000 q_{1} ⊢ 00 q_{2} ⊢ 0 q_{2} \in F .$

A computação termina quando não é possível fazer mais transições. Neste exemplo o autómato fica no estado $q_{2} \in F$ . Portanto $p = 000$ é aceite por $A$ .

O que acontece com $p = 010$ ? A computação é a sequência: $q_{0} ⊢ 010 q_{1} ⊢ 10 q_{3} ⊢ 0 q_{3} \neq \in F .$

Neste caso a computação termina no estado $q_{3} \neq \in F$ . Portanto $010$ é rejeitada por $A$ .

Diagramas dos Autómatos Finitos Deterministas

Tal como com as expressões regulares, a visualização gráfica dos autómatos finitos deterministas é uma ferramenta útil.

Diagrama de um AFD. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFD. O diagrama de $A$ é um grafo orientado em que:

Os vértices são os estados de controlo $q \in Q$ .

Os arcos são definidos pela transição. Se $q^{'} = δ (q, a)$ então o diagrama tem o arco

O (único) vértice com o estado inicial é assinalado por um arco órfã a entrar:

Os (vários) vértices com estados finais são assinalados por um círculo duplo:

Por exemplo, o AFD usado nos exemplos acima tem o seguinte diagrama:

Diagrama de um AFD

Transição Estendida

A transição de um AFD está definida para cada símbolo do alfabeto de entrada: $δ : Q \times Σ \to Q$ . No entanto é mais conveniente estender as transições a palavras: $\hat{δ} : Q \times Σ^{*} \to Q$ .

Transição Estendida. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFD. A função de transição estendida tem assinatura $\hat{δ} : Q \times Σ^{*} \to Q$ e fica definida pelas seguintes regras recursivas:

base - palavra vazia $\hat{δ} (q, λ) = q$ .

base - símbolos Para cada $a \in Σ, \hat{δ} (q, a) = δ (q, a)$ .

passo Se $p \in Σ^{*}, a \in Σ$ então $\hat{δ} (q, p a) = δ (\hat{δ} (q, p), a)$ .

Intuitivamente, $\hat{δ} (q, p)$ é o estado em que o AFD fica depois de processar a palavra $p$ a partir do estado $q$ .

Por exemplo, usando o AFD anterior: $\hat{δ} (q_{0}, 000) = δ (\hat{δ} (q_{0}, 00), 0) = δ (δ (\hat{δ} (q_{0}, 0), 0), 0) = δ (δ (δ (q_{0}, 0), 0), 0) = δ (δ (q_{1}, 0), 0) = δ (q_{2}, 0) = q_{2}$ e $\hat{δ} (q_{0}, 010) = δ (\hat{δ} (q_{0}, 01), 0) = δ (δ (\hat{δ} (q_{0}, 0), 1), 0) = δ (δ (δ (q_{0}, 0), 1), 0) = δ (δ (q_{1}, 1), 0) = δ (q_{3}, 0) = q_{3}$

Com transições estendidas a escrita de certas definições e condições fica mais compacta e intuitiva:

Computação $\hat{δ} (q, p) = q^{'} \Leftrightarrow (q, p) ⊢_{A}^{*} (q^{'}, λ)$ .
Aceitação $p \in Σ^{*}$ é aceite pelo AFD $A$ se, e só se $\hat{δ} (q_{I}, p) \in F$ . Se $\hat{δ} (q_{I}, p) \neq \in F$ então $p$ é rejeitada.

Linguagens Reconhecidas pelos AFD

É altura de começar a fazer a ligação entre as linguagens regulares e os AFD.

Linguagem Reconhecida por um AFD. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFD.

A linguagem reconhecida (ou aceite) por $A$ é $L (A) = {p \in Σ^{*} : \hat{δ} (q_{I}, p) \in F} .$

Dois AFD são equivalentes se aceitam a mesma linguagem.

Tal como com as expressões regulares, a definição de "equivalência" depende das linguagens associadas.

Conclusão

Nesta secção definiu-se um modelo de "computação" simples, os autómatos finitos deterministas e associou-se uma linguagem a cada AFD.

A intenção aqui é obter-se um modelo de computação das linguagens regulares. Portanto é preciso responder afirmativamente a estas duas questões:

Qualquer linguagem regular é aceite por um AFD?
Qualquer linguagem aceite por um AFD é regular?

Estas duas questões são tratadas na próxima secção.

Computação Não Determinista

Generalização dos autómatos deterministas.

Computação Não Determinista

Introdução

Com vista a obter-se um modelo de computação das linguagens regulares, estão por responder duas questões:

Qualquer linguagem regular é aceite por um AFD?
Qualquer linguagem aceite por um AFD é regular?

Formalmente, para responder a estas questões, mostra-se como obter um AFD "equivalente" a uma ER dada e, reciprocamente, como obter uma RE "equivalente" a um dado AFD.

Para construir estas equivalências é necessária estudar uma variante não determinista dos AFD.

Autómatos Finitos Não Deterministas

Nos AF deterministas há sempre exatamente uma transição para cada combinação $(q, a) \in Q \times Σ$ . Isto é, no diagrama, de cada estado $q$ sai sempre exatamente uma aresta $a$ , para cada $a \in Σ$ .

Diagrama de Um AFD.

De cada vértice sai exatamente uma aresta para cada símbolo.

Para os diagramas das expressões regulares o caso é diferente:

Algumas arestas "são" $λ$ .
Não é necessário sair uma aresta para cada símbolo.
Podem sair várias arestas com o mesmo símbolo.

Por exemplo, para a expressão regular $(11 \cup 0)^{*} (00 \cup 1)^{*}$ tem-se o diagrama

Diagrama de uma ER.

Não se verificam as restrições dos AFD.

Intuitivamente, as arestas dos AFD são caminhos obrigatórios enquanto que as arestas das RE são caminhos possíveis.

Os Autómatos Finitos Não Deterministas generalizam os AFD com todos os tipos de arestas das ER. Desta forma obtém-se um modelo computacional das ER que pode "correr" e ser analisado em termos de desempenho.

Autómato Finito Não Determinista (AFND). Um Autómato Finito Não Determinista (AFND) é um tuplo $A = (Q, Σ, δ, q_{I}, F)$ em que

Estados de Controlo $Q$ é um conjunto finito.

Alfabeto de Entrada $Σ$ é um alfabeto.

Transição $δ : Q \times (Σ \cup {λ}) \to P (Q)$ é uma função.

Estado Inicial $q_{I} \in Q$ .

Estados Finais ou de Aceitação $F \subseteq Q$ .

A diferença entre as definições de AFD e AFND está na assinatura da transição:

A assinatura da transição dos AFD é $δ : Q \times Σ \to Q$ .
Nos AFND acrescenta-se a palavra vazia $λ$ a $Σ$ . Desta forma, nos diagramas algumas arestas também podem ser $λ$ , além de $a \in Σ$ .
Em vez de $δ (q, x)$ ser um único estado de controlo, nos AFND é um conjunto de possíveis estados, incluindo nenhum. Isto é, em vez de $δ (q, x) \in Q$ , nos AFND $δ (q, x) \subseteq Q$ .

É necessário replicar nos AFND o percurso feito com os AFD. Em particular, definir para os AFND o que é uma configuração, computação, palavra e linguagem aceite. Porém, é mais útil começar por definir o diagrama de um AFND.

Diagrama de um AFND. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFND. O diagrama de $A$ define-se como no caso dos AFD, tendo em conta que algumas arestas podem ser $λ$ .

Por exemplo, dado o AFND com estado inicial $q_{I} = 0$ , estados finais $F = {2}$ e transição $q 012 0 \emptyset {2} {2} 1 {0, 1} {1, 2} \emptyset λ {1} \emptyset {1}$ o diagrama que se obtém é

Exemplo de Diagrama de um AFND

Note-se que:

A tabela da transição tem uma coluna adicional, $λ$ .
As "células" da tabela são subconjuntos de estados de controlo. Um valor possível é o conjunto vazio $\emptyset$ .
Neste primeiro exemplo os conjuntos foram denotados com ${\dots}$ mas sempre que possível será usada uma notação mais compacta:
- Em vez de se escrever " ${0, 2}$ " escreve-se apenas " $02$ ", " $02$ " ou " $0, 2$ " se a vírgula for mesmo necessária.
- O conjunto vazio é representado por nada: em vez de " $\emptyset$ " escreve-se apenas "".
Os estados finais podem ser assinalados com o prefixo " $f$ " e o estado inicial com um prefixo " $i$ ". Se nada for indicado o estado inicial é sempre $q_{0}$ ou $0$ e dispensa-se a indicação de que é inicial.

De acordo com estas convenções a tabela da transição acima fica $01 f 2 02210112 λ 11$ e define completamente o AFND $A$ . Isto é, lendo a tabela determinam-se $Q, Σ, δ, q_{I}, F$ todos os atributos que definem um AFND.

Tal como observado para os AFD, a função de transição de um AFND é quase sempre representada por uma tabela mas por vezes é conveniente apresentá-la como um conjunto de triplos: ${(i, a, J) : J = δ (i, a)} .$

A transição acima, como um conjunto de triplos, fica: ${(0, 0, \emptyset), (0, 1, {0, 1}), (0, λ, {1}), (1, 0, {2}), (1, 1, {1, 2}), (1, λ, \emptyset), \dots}$

Observação: No caso dos AFD os triplos são $(i, a, j) \in Q \times Σ \times Q$ e para os AFND os triplos são $(i, a, J) \in Q \times Σ \times P (Q)$ . Enquanto que nos AFD $j \in Q$ , nos AFND $J \subseteq Q$ , podendo $J$ ser vazio, ter zero, um, dois, $n$ elementos de $Q$ .

Configuração. Computação AFND. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFND.

A definição de configuração como um par $(q, s) \in Q \times Σ^{*}$ permanece igual ao caso dos AFD.

A computação da palavra $p = a_{1} a_{2} \dots a_{n} \in Σ^{*}$ pelo AFND $A$ é uma sequência de configurações $(q_{0}, p_{0}) ⊢_{A} (q_{1}, p_{1}) ⊢_{A} \dots ⊢_{A} (q_{n}, p_{n})$ em que:

base (configuração inicial) $q_{0} = q_{I}$ e $p_{0} = p$ .

passo (processamento do símbolo ativo): $q_{i + 1} \in δ (q_{i}, a)$ e $p_{i} = a p_{i + 1}$ .

passo (transição vazia): $q_{i + 1} \in δ (q_{i}, λ)$ e $p_{i} = p_{i + 1}$ .

fim $p_{n} = λ$ ou não há mais passos possíveis.

Ao contrário do que acontece com os AFD, nos AFND cada palavra pode ter mais do que uma computação possível.

Por exemplo, a palavra $01$ tem três computações possíveis:

$0 ⊢ λ 1 ⊢ 0 2 ⊢ λ 1 ⊢ 1 1 \neq \in F$ : rejeita?
$0 ⊢ λ 1 ⊢ 0 2 ⊢ λ 1 ⊢ 1 2 \in F$ : aceita?
$0 ⊢ λ 1 ⊢ 0 2 ⊢ λ 1 ⊢ 1 2 ⊢ λ 1 \neq \in F$ : rejeita?

Esta situação, em que as computações de uma palavra podem terminar em vários estados, alguns finais e outros não, torna a definição de palavra aceite um pouco mais complicada do que para os AFD:

Palavra Aceite. Linguagem Reconhecida (AFND). Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFND.

Uma palavra $p \in Σ^{*}$ é aceite por $A$ se existe alguma computação de $p$ por $A$ que termina num estado final $q \in F$ depois de terem sido lidos todos os símbolos de $p$ . Isto é, se entre todas as computações de $p$ por $A$ alguma termina numa configuração $(q, λ)$ com $q \in F$ .

A linguagem reconhecida (ou aceite) por $A$ é o conjunto de todas as palavras aceites por $A$ : $L (A) = {p : \exists (q_{I}, p) ⊢_{A}^{*} (q, λ), q \in F}$

Neste ponto a situação em relação ao Problema Principal de ALP é a seguinte :

As Linguagens e as Expressões Regulares são candidatas para formalizar rigorosamente as linguagens de programação. Idealmente, cada linguagem de programação poderia ser representada por uma ER.
Os Autómatos Finitos Deterministas são candidatos para resolver computacionalmente a questão de saber se um palavra dada está, ou não, numa certa linguagem regular.
Mas os AFD parecem ser demasiado restritivos para representar as ER. Comparando os respetivos diagramas, não há arestas vazias, etc.
Os Autómatos Finitos Não Deterministas generalizam os AFD de forma a suportarem todos os tipos de arestas das ER.

De forma a resolver a questão da representação computacional das linguagens regulares, há que responder afirmativamente às seguintes duas questões;

Qualquer linguagem regular é aceite por um AFND?
Qualquer linguagem aceite por um AFND é regular?

Equivalência entre Expressões Regulares e Autómatos Finitos Não Deterministas

Para estabelecer a equivalência entre ER e AFND têm de ser resolvidos dois problemas:

ER → AFND (Construção de Thompson): Dada uma ER qualquer, $e$ , encontrar um AFND $A$ tal que $L (A) = L (e)$ (isto é, Qualquer linguagem regular é aceite por um AFND?).
AFND → ER (Algoritmo de Kleene): Dado um AFND qualquer, $A$ , encontrar uma ER $e$ tal que $L (e) = L (A)$ (isto é, Qualquer linguagem aceite por um AFND é regular?).

A resolução do primeiro problema usa a "Construção de Thompson" descrita já a seguir. Para resolver o segundo problema usa-se o "Algoritmo de Kleene", que remove um a um os vértices do diagrama do AFND.

Construção de Thompson

O primeiro problema é de resolução muito fácil, considerando os diagramas das ER e dos AFND:

Construção de Thompson. Dada uma ER $e$ sobre $Σ$ , o diagrama de $e$ pode ser interpretado como o diagrama de um AFND $A$ . Nesse caso $L (A) = L (e)$ .

Por exemplo, seja $e = a \cup b (a \cup b)^{*}$ . Numerando os vértices do seu diagrama da esquerda para a direita (mas serve qualquer critério desde que cada vértice fique com um "nome" diferente dos restantes) obtém-se:

Exemplo de um Diagrama da ER $a \cup b (a \cup b)^{*}$

Seja $A$ o AFND que se obtém deste diagrama, descrito pela tabela

$012 f 3 a 32 b 12 λ 23$

A "equivalência" entre $e$ e $A$ depende de se verificarem as seguintes duas condições:

$L (e) \subseteq L (A)$ : Cada palavra de $L (e)$ é aceite por $A$ ou, equivalentemente, $\overline{L (A)} \subseteq \overline{L (e)}$ : cada palavra rejeitada por $A$ não está em $L (e)$ .
$L (A) \subseteq L (e)$ : Cada palavra aceite por $A$ está em $L (e)$ ou, equivalentemente, $\overline{L (e)} \subseteq \overline{L (A)}$ : cada palavra que não está em $L (e)$ é rejeitada por $A$ .

A demonstração completa e formal de cada um dos pontos anteriores sai do âmbito de ALP. Mas a verificação de alguns casos é um exercício importante.

Palavras de $L (e)$ : $a, b, ba, baba$ . Estas palavras são aceites por $A$ ?
Palavras que não estão em $L (e)$ : $λ, aa, ab$ . Estas palavras são rejeitadas por $A$ ?

Para verificar que a palavra $p$ é aceite por $A$ , basta que uma computação de $p$ por $A$ processe todos os símbolos $p$ e termine num estado final.

Por exemplo, $p = a$ tem a seguinte computação por $A$ : $0 ⊢ a 3 \in F$ . Portanto $p = a$ é aceite por $A$ .

Para $p = b$ há a seguinte computação: $0 ⊢ b 1 ⊢ λ 2 ⊢ λ 3 \in F$ . Todos os símbolos de $p = b$ foram processados e a computação termina num estado final. Portanto $p = b$ é aceite.

Exercício. Verifique que as restantes palavras de $L (e)$ listadas acima também são aceites por $A$ .

Para verificar que a palavra $p$ é rejeitada por $A$ é necessário que nenhuma computação de $p$ por $A$ processe todos os símbolos $p$ e termine num estado final.

Por exemplo, $p = λ$ tem apenas uma computação por $A$ : $0 \neq \in F$ (começa no estado inicial e não avança mais).

Embora esta computação processe todos os símbolos de $p = λ$ , não termina num estado final. Como não há mais computações de $p = λ$ por $A$ conclui-se que $A$ rejeita $p = λ$ .

Se $p = aa$ também só há uma computação possível: $0 ⊢ a 3 \in F$ e daqui não é possível avançar mais. Neste caso, embora a computação tenha terminado num estado final, faltou processar todos os símbolos de $p = aa$ . Portanto esta palavra é rejeitada.

Exercício. Verifique que as restantes palavras listadas acima que não estão em $L (e)$ também são rejeitadas por $A$ .

Algoritmo de Kleene

Com a Construção de Thompson fica estabelecido que qualquer linguagem regular é aceite por um AFND. Falta verificar que qualquer linguagem aceite por um AFND é regular.

Para esse efeito apresenta-se um método, o "Algoritmo de Kleene", que transforma o diagrama de um AFND numa expressão regular "equivalente".

Neste processo o diagrama é transformado por uma sequência de passos onde se remove um vértice de cada vez. O vértice removido é substituído por certas ER. No fim do processo fica apenas o vértice inicial e um vértice final, ligados por uma aresta com a ER final.

Um exemplo, ainda informal

Dado o seguinte AFND na forma de um diagrama:
Representa-se por $E_{ij}$ a expressão da aresta que liga o vértice $i$ ao vértice $j$ . Por exemplo, $E_{12} = a, E_{23} = λ$ .
Neste diagrama:
1. Nenhuma aresta entra no vértice inicial.
2. Existe apenas um vértice final.
3. Nenhuma aresta sai do vértice final.
Para eliminar o vértice $1$ :
1. Que caminhos "passam em $1$ "? Há dois: $0 \to 1 \to 2$ e $2 \to 1 \to 2$ .
2. Seja $i \to k \to j$ um desses caminhos. Adiciona-se ao diagrama a aresta $i \to j$ com $E_{ij} \cup E_{ik} (E_{kk})^{*} E_{kj}$ .
3. Repete-se o passo anterior para todos os caminhos que passam no vértice a eliminar.
O novo diagrama, sem o vértice $1$ , é:
Eliminado o vértice $2$ , obtém-se:
Restam apenas o vértice inicial e o final. A expressão regular "equivalente" ao AFND é $a (ba)^{*}$ .

O núcleo do processo está no passo 4 mas antes de começar é preciso que o diagrama do AFND esteja "bem preparado", conforme as condições do passo 3.

Diagrama Bem Preparado. Um diagrama está bem preparado se

Nenhuma aresta entra no vértice inicial.

Existe apenas um vértice final.

Nenhuma aresta sai do vértice final.

Nem todos os diagramas estão bem preparados mas é sempre possível transformar um diagrama de forma a obter-se outro equivalente e bem preparado:

Autómato Bem Preparado. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFND.

O AFND $A^{'} = (Q \cup {q_{I}^{'}, q_{f}}, Σ, δ^{'}, q_{I}^{'}, {q_{F}})$ em que:

$q_{I}^{'} \neq = q_{F}$ e ${q_{I}^{'}, q_{F}} \cap Q = \emptyset$ .

$δ^{'} (q_{I}^{'}, λ) = {q_{I}}$ .

$δ^{'} (q, λ) = {q_{F}}$ para cada $q \in F$ .

$δ^{'} (q, x) = δ (q, x)$ nos restantes casos.

está bem preparado e é equivalente a $A$ .

Por exemplo, se $A$ for dado pela tabela $δ 0 f 1 a 1 b 0 λ$ não está bem preparado porque o estado inicial, $0$ , recebe uma aresta de $1$ e, também, porque sai uma aresta do estado final. Um AFND equivalente e bem preparado é $δ^{'} i q_{I}^{'} 01 f q_{F} a 1 b 0 λ 0 q_{F}$ que está bem preparado. Em termos de diagramas:

Diagrama Mal Preparado	Diagrama Equivalente Bem Preparado

Com autómatos bem preparados pode aplicar-se o processo de eliminação de vértices.

Algoritmo de Kleene. Sejam $A$ um AFND bem preparado e $E_{ij}$ a ER da aresta $i \to j$ no diagrama de $A$ .

O caminho $i \to k \to j$ passa no vértice $k$ se $i, j \neq = k$ (pode ser $i = j$ ) e no diagrama existem arestas $i \to k$ e $k \to j$ .

A eliminação do vértice $k$ produz um novo diagrama idêntico ao anterior exceto:

O novo diagrama não tem o vértice $k$ .

Para cada caminho $i \to k \to j$ do diagrama original, o novo diagrama tem a aresta $i \to j$ com valor

$E_{ij} \cup E_{ik} (E_{kk})^{*} E_{kj} .$

No diagrama que se obtém quando foram eliminados todos os vértices exceto o inicial e final, a expressão regular $E_{I F}$ que está na aresta $q^{'} I \to q F$ é "equivalente" ao AFND $A$ no sentido em que $L (E_{I F}) = L (A) .$

Um exemplo mais complicado, passo a passo. Seja $A$ o seguinte diagrama/AFND, que não está bem preparado:

Fig: Exemplo TK 01

Uma versão equivalente, bem preparada é

Fig: Exemplo TK 02

Eliminar $0$ . Caminhos que passam em $0$ :

$I \to 0 \to 1$ . ER resultante: $λ \cup a$ .
$I \to 0 \to 2$ . ER resultante: $b$ .

Fig: Exemplo TK 03

Eliminar $2$ . Caminhos que passam em $2$ :

$I \to 2 \to 3$ . ER resultante: $b$ .
$3 \to 2 \to 3$ . ER resultante: $a \cup b$ .

Fig: Exemplo TK 04

Eliminar $3$ . Caminhos que passam em $3$ :

$I \to 3 \to 1$ . ER resultante: $λ \cup a \cup b (a \cup b)^{*} a$ .
$1 \to 3 \to 1$ . ER resultante: $b \cup b (a \cup b)^{*} a$ .

Fig: Exemplo TK 05

Eliminar $1$ . Caminhos que passam em $1$ :

$I \to 1 \to F$ . ER resultante, e final: $x = (λ \cup a \cup b (a \cup b)^{*} a) (b \cup b (a \cup b)^{*} a)^{*} .$

A ER final pode ser um pouco simplificada: $x = (λ \cup a) (b \cup b (a \cup b)^{*} a)^{*} .$

Exercícios:

Aplique a Construção de Thompson à ER $x$ acima.
Escolha palavras de $L (x)$ e verifique que $A$ as aceita.
Encontre palavras de $L (A)$ e verifique que estão em $L (x)$ .
O que se passa com a palavra $aa$ ? Está em $L (x)$ ? E em $L (A)$ ?

Equivalência entre AFND e AFD

A Construção de Thompson e o Algoritmo de Kleene asseguram que os AFND são "equivalentes" às ER, no sentido em que os AFND e as ER definem exatamente as mesmas linguagens.

Mas os AFND são um mau modelo computacional porque pode ser necessário um número exponencial (no número de estados do autómato) para decidir se $p \in L (A)$ .

Para computar $p \in L (A)$ não se sabe, à partida, quantos "passos" vão ser necessários. No caso em que $p \neq \in L (A)$ é preciso testar todas computações de $p$ por $A$ .

O problema da eficiência da computação não se coloca nos AFD: Demora sempre exatamente $∣ p ∣$ passos, o que é um desempenho ótimo (no sentido em que não há melhor).

Como os AFND generalizam os AFD, todas as linguagens aceites por AFD são também aceites por AFND.

Nesta secção mostra-se que os AFD e os AFND são equivalentes: As linguagens aceites pelos AFD são exatamente as linguagens aceites pelos AFND.

Com as transições vazias, um AFND pode percorrer vários estados sem processar símbolos, ao contrário do que acontece com os AFD. Esta situação fica representada com o fecho vazio e com a transição de entrada.

Fecho Vazio. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFND e $q \in Q$ .

O fecho vazio de $q$ , $fecho_{λ} (q)$ , é o conjunto de todos os estados que podem ser alcançados a partir de $q$ com zero ou mais transições vazias. Formalmente:

base $q \in fecho_{λ} (q)$ .

passo Se $p \in fecho_{λ} (q)$ e $p^{'} \in δ (p, λ)$ então também $p^{'} \in fecho_{λ} (q)$ .

Também devido às transições vazias, $δ (q, a)$ não contém todos os estados que podem ser alcançados a partir de $q$ lendo o símbolo $a$ . Para esse efeito tem-se a transição de entrada:

Transição de Entrada. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFND.

A transição de entrada é a função de assinatura $δ_{λ} : Q \times Σ \to P (Q)$ que, para cada $q \in Q, a \in Σ$ , define o conjunto dos estados que podem ser alcançados a partir de $q$ lendo o símbolo $a$ . Isto é: $δ_{λ} (q, a) = q^{'} \in fecho_{λ} (q) ⋃ fecho_{λ} (δ (q^{'}, a)) .$

Por exemplo, seja $A$ o AFND definido pela tabela $q 01 f 2 a 22 b 0112 λ 11 fecho_{λ} (q) 01121$ com o fecho vazio de cada estado já calculado e com o seguinte diagrama

Transição de Entrada: Diagrama do AFND acima

A transição de entrada de alguns casos: $δ_{λ} (0, b) δ_{λ} (0, a) = {0, 1, 2} = {2, 1}$ Neste caso, por exemplo, $2 \in δ_{λ} (0, a)$ porque $0 ⊢ λ 1 ⊢ a 2$ é uma computação de $A$ . Já $1 \in δ_{λ} (0, a)$ de duas maneiras diferentes: $1 ⊢ a 1$ e $1 ⊢ a 2 ⊢ λ 1$ .

Exercício: Calcule todas as transições de entrada deste exemplo.

Este "desvio" pelo fecho vazio e transição de entrada serve para formalizar as ferramentas que faltam para o objetivo desta secção: Mostrar que para cada AFND $A$ existe um AFD $A^{'}$ "equivalente" no sentido em que $L (A) = L (A^{'})$ .

Simulação de Não Determinismo. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFND.

O AFD equivalente a $A$ é o AFD $A^{'} = (Q^{'}, Σ, δ^{'}, q_{I}^{'}, F^{'})$ em que:

Estado Inicial $q_{I}^{'} = fecho_{λ} (q_{I})$ .

Transição $δ^{'} (q, a) = ⋃_{p \in q} δ_{λ} (p, a)$ .

Estados de Controlo $Q^{'}$ é definido recursivamente por

base $q_{I}^{'} \in Q^{'}$ .

passo Se $q \in Q^{'}$ então, para cada $a \in Σ, δ^{'} (q, a) \in Q^{'}$ .

fecho Mais nenhum estado está em $Q^{'}$ .

Estados Finais $F^{'} = {q \in Q^{'} : q \cap F \neq = \emptyset}$ .

Neste caso $L (A) = L (A^{'}) .$

Por exemplo, para o AFND

Um AFND para $a^{} b^{} c^{*}$

o cálculo de $δ^{'}$ e de $Q^{'}$ é feito em conjunto:

$δ^{'} i f q_{I}^{'} = fecho_{λ} (0) = \underline{02} f \underline{12} f \underline{1} \emptyset a 02 \emptyset \emptyset \emptyset b 1212 \emptyset \emptyset c 111 \emptyset$

Os estados de $A^{'}$ são conjuntos de estados de $A$ . Para evitar uma notação muito pesada (por exemplo, ${0, 2}$ ) omitem-se as chavetas e as vírgulas (e escreve-se apenas $02$ ). O texto vermelho $x yz$ representa estados "novos" na tabela e os estados finais de $A$ estão sublinhados. O respetivo diagrama é

Um AFD equivalente ao AFND para $a^{} b^{} c^{*}$

O teorema/método da Simulação de Não Determinismo assegura que estes dois autómatos são equivalentes, isto é, reconhecem a mesma linguagem.

Conclusão

Uma vantagem dos AFD é que a computação é linear no comprimento da palavra pois executa exatamente $∣ p ∣$ passos para computar a resposta a $p \in L (A^{'})$ enquanto que para o AFND a computação da resposta $p \in L (A)$ é exponencial.

Este ganho no número de passos tem um custo: se o AFND $A$ tem $n$ estados então $A^{'}$ , o AFD equivalente, pode ter até $2^{n}$ estados.

Estão determinadas três equivalências:

As ER e os AFND são equivalentes devido à Construção de Thompson e ao Algoritmo de Kleene.

Os AFND e os AFD são equivalentes devido à Definição de AFND e à Simulação de Não Determinismo.

Portanto, também as ER e os AFD são equivalentes.

Portanto

Os AFD proporcionam um bom modelo computacional para as ER.

Mas ainda há questões importantes a resolver. A próxima secção trata de formas de reduzir o tamanho dos AFD e de facilitar a construção automática de AFD e AFND antes de ser tratada a questão final, saber se "as linguagens regulares são adequadas para todas as linguagens de programação?"

Minimização e Composição de AFD

Operações com autómatos.

Minimização e Composição de AFD

Introdução

Nas secções anteriores ficou provado que os AFD, AFND e as ER são equivalentes no sentido em que todos definem exatamente a classe das Linguagens Regulares.

Essa demonstração usa algoritmos para:

Converter uma ER num AFND (Construção de Thompson).
Converter um AFND numa ER (Algoritmo de Kleene).
Simular um AFND por um AFD (Teorema da Simulação).

Comparando os AFD com os AFND:

Autómato	Número de Estados	Comprimento das Computações
Determinista	Ineficiente	Eficiente
Não Determinista	Eficiente	Ineficiente

Em termos de eficiência "absoluta" nenhum dos modelos (AFD e AFND) é superior. Mas enquanto não há nada a fazer em relação às computações não deterministas, em certos casos é possível reduzir o número de estados de um AFD.

Também interessa definir operações com autómatos que permitam acompanhar as operações das ER (união, concatenação, iteração) e também explorar outras possibilidades como a negação, a interseção e o processamento paralelo.

Minimização de AFD

Seja $L$ a linguagem das palavras binárias (sobre ${a, b}$ ) cujo quinto símbolo a contar do fim é $a$ . Esta linguagem é definida pela ER $(a \cup b)^{*} a (a \cup b) (a \cup b) (a \cup b) (a \cup b)$ a que corresponde o diagrama e AFND seguinte:

AFND para $(a \cup b)^{*} a (a \cup b) (a \cup b) (a \cup b) (a \cup b)$

Exercício: A aplicação direta do teorema da simulação determinista a este AFND produz um autómato com $32$ estados de controlo.

A simulação de um AFND com $n$ estados de controlo pode produzir até $2^{n}$ estados no autómato determinista equivalente (exercício: porquê?).

Estados Indistintos

Dois AFD são equivalentes se aceitam a mesma linguagem. Por exemplo, para a linguagem $a^{*}$ :

Autómato $A$	Autómato $B$

No Autómato $B$ os estados $I$ e $1$ são indistintos no seguinte sentido: Qualquer palavra processada a partir do estado $I$ é aceite SSE também for aceite se processada a partir do estado $1$ .

Por exemplo, se $p = λ$ e o autómato estiver no estado $I$ então $p$ é "aceite". Também é "aceite" se o autómato estiver no estado $1$ . Por outro lado $p = b$ é rejeitada quer o autómato esteja no estado $I$ quer no $1$ .

Portanto, tanto $I$ como $1$ definem sempre os mesmos resultados em termos de aceitação/rejeição de palavras. Formalmente:

Estados Indistintos. Sejam $A = (Q, Σ, δ, q_{I}, F)$ um AFD e $i, j \in Q$ dois estados. Então $i$ é indistinto de $j$ se, para cada palavra $p \in Σ^{*}$ , $\hat{δ} (i, p) \in F \Leftrightarrow \hat{δ} (j, p) \in F .$ Em particular, se $i \in F$ e $j \in Q ∖ F$ não são indistintos.

Agrupando estados indistintos obtém-se um novo AFD com o número mínimo de estados para aquela linguagem regular, isto é, um Autómato Mínimo. Antes da respetiva definição formal é conveniente descrever um algoritmo para particionar os estados indistintos.

O objetivo é particionar o conjunto de estados em grupos de forma que dois estados estão no mesmo grupos se e só se são indistintos.

Partição dos Estados Indistintos. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFD:

Iniciar a partição $P = {Q ∖ F, F}$ .

Enquanto existirem grupos $X, Y \in P$ com $i, j \in X$ e $a \in Σ$ tais que $δ (i, a) \in Y, δ (j, a) \neq \in Y$ ( $X$ é inconsistente):

Retirar $X$ da partição $P$ : $P \to P ∖ {X}$ .

Acrescentar os estados de $X$ concordantes com $i$ em $a$ : $P \to P \cup {k \in X : δ (k, a) \in Y}$ .

Acrescentar os estados de $X$ discordantes de $i$ em $a$ : $P \to P \cup {k \in X : δ (k, a) \neq \in Y}$ .

Os passos deste ciclo refinam $X$ de forma a eliminar discordâncias de $i \in X$ sobre $a \in Σ$ . O resultado é que a partição $P$ troca o grupo inconsistente $X$ por dois grupos mais pequenos mas "menos" inconsistentes, isto é, onde os estados estão "mais próximos" de serem indistintos.

A partição final é formada apenas por grupos consistentes, isto é, em que todos os estados são indistintos (no limite esses grupos têm apenas um estado). Os grupos dessa partição são os estados do AFD mínimo equivalente ao AFD inicial.

Autómato Mínimo. Sejam $A = (Q, Σ, δ, q_{I}, F)$ um AFD e $P$ a partição dos estados indistintos.

Para cada grupo $X \in P$ e cada $a \in Σ$ $δ^{'} (X, a) = Y$ em que $Y \in P$ é o grupo que contém $δ (i, a)$ com $i \in X$ .

O AFD Mínimo (ou reduzido) equivalente a $A$ é $A^{'} = (P, Σ, δ^{'}, q_{I}^{'}, F^{'})$ em que:

O estado inicial, $q_{I}^{'}$ , é o grupo de $P$ que contém o estado inicial $q_{I}$ de $A$ .

Os estados finais, $F^{'}$ , são os grupos de $P$ que estão contidos em $F$ . Isto é

$F^{'} = {X \in P : X \subseteq F} .$

A construção do autómato mínimo a partir da definição está sujeita a erros, pelo que são ilustrados de seguida dois métodos com vista a sistematizar e facilitar esse processo.

Dado o AFD $A$ pela seguinte tabela:

$δ i 0 f 1 2 f 3 45 a 143554 b 425255$

Construção do Autómato Mínimo por Tabelas de Transição

Iniciar grupos, detetar e assinalar inconsistências:

$0 f 1 2 f 3 45 δ A B A B A A 143554 a B A B A A A 425255 b A A A A A A$

Separar inconsistências, detetar e assinalar novas inconsistências:

$0 f 1 2 f 3 45 δ A B A B A A A B A B C C 143554 a B A B A A A B C B C C C 425255 b A A A A A A C A C A C C$

Não existem mais inconsistências: Agrupar e escrever a tabela do AFD mínimo:

$δ q_{I}^{'} = A = {0, 2} f B = {1, 3} C = {4, 5} a B C C b C A C$

Construção do Autómato Mínimo por Diagramas

O diagrama do AFD dado é:

AFD dado, com a partição inicial.

$0, 2$ e $4, 5$ discordam em $a$ .

Todos os grupos são consistentes.

Diagrama do ADF Mínimo

Foram descritos dois métodos para reduzir o número de estados de um AFD (minimizar). Ambos produzem o mesmo resultado: um autómato determinista com o menor número possível de estados e que seja equivalente a um AFD dado.

Embora isto não resolva completamente o potencial aumento exponencial do número de estados na passagem de AFND para AFD, produz um resultado ótimo, no sentido em que não existe melhor (isto é, por vezes o ótimo pode ainda ser "mau").

Composição

A representação é importante. Intuitivamente, a numeração romana é equivalente à árabe no sentido que representam os mesmos números. Considere o Problema A: "Multiplicar DXXXIX por XVII" e o Problema B: "Multiplicar 89 por 17". Embora os problemas A e B sejam o mesmo, é muito mais simples resolver B porque a representação árabe dos números "é compatível com" a multiplicação, ao contrário da representação romana.

As ER são construídas a partir da base ( $\emptyset, λ, a \in Σ$ ) usando operações bem definidas ( $\cdot, \cup,^{*}$ ). Desta forma é possível decompor uma ER nas suas componentes, o que proporciona uma importante forma de análise com vista a explorar as suas propriedades.

Por outro lado, em geral, os autómatos "surgem" completamente definidos e é difícil relacionar um autómato com outro. Dado que as ER, os AFD e os AFND são "equivalentes", seria estranho que não fosse possível fazer também um estudo estruturado dos autómatos.

As operações com autómatos usam os Autómatos Bem Preparados pois estes têm uma forma adequada a serem "operados".

Começando pela concatenação, a ideia intuitiva para $A B$ é "correr" primeiro $A$ e continuar em $B$ :

Concatenação de AFND. Sejam $A = (Q^{A}, Σ, δ^{A}, q_{I}^{A}, {q_{F}^{A}})$ e $B = (Q^{B}, Σ, δ^{B}, q_{I}^{B}, {q_{F}^{B}})$ dois AFND bem preparados sobre um alfabeto comum, $Σ$ , e com os estados de controlo disjuntos, $Q^{A} \cap Q^{B} = \emptyset$ .

Então, a concatenação de $A$ com $B$ é o AFND $A B$ , definido por $(Q^{A} \cup Q^{B}, Σ, δ^{A B}, q_{I}^{A}, {q_{F}^{B}})$ em que

$δ^{A B} = δ^{A} \cup δ^{B} \cup {(q_{F}^{A}, λ, q_{I}^{B})} .$

A linguagem reconhecida por $A B$ é a concatenação da linguagem reconhecida por $A$ com a linguagem reconhecida por $B$ : $L (A B) = L (A) L (B) .$

Exercício: $A B$ está bem preparado?

Por exemplo, se $A = ({0, 1}, {a, b}, 0, {(0, a, 1)}, {1})$ e $B = ({2, 3}, {a, b}, {(2, b, 3)}, 2, {3})$ (exercício: verifique que ambos são bem preparados e identifique as respetivas linguagens) então $A B = ({0, 1, 2, 3}, {a, b}, {(0, a, 1), (2, b, 3), (1, λ, 2)}, 1, {3}) .$

Exercício: Traduza este exemplo para diagramas. Qual é a linguagem aceite por $A B$ ?

A união de autómatos é semelhante à concatenação. Intuitivamente, o primeiro "passo" é decidir se "corre" $A$ ou $B$ . A computação da união termina a seguir a terminar a computação do autómato "escolhido" no início.

União de AFND. Sejam $A = (Q^{A}, Σ, δ^{A}, q_{I}^{A}, {q_{F}^{A}})$ e $B = (Q^{B}, Σ, δ^{B}, q_{I}^{B}, {q_{F}^{B}})$ dois AFND bem preparados sobre um alfabeto comum, $Σ$ , e com os estados de controlo disjuntos, $Q^{A} \cap Q^{B} = \emptyset$ .

Então, a união de $A$ com $B$ é o AFND $A \cup B$ , definido por $(Q^{A} \cup Q^{B} \cup {q_{I}, q_{F}}, Σ, δ^{A \cup B}, q_{I}, {q_{F}})$ em que

$δ^{A \cup B} = δ^{A} \cup δ^{B} \cup {(q_{I}, λ, {q_{I}^{A}, q_{I}^{B}}), (q_{F}^{A}, λ, {q_{F}}), (q_{F}^{B}, λ, {q_{F}})} .$

A linguagem reconhecida por $A \cup B$ é a união da linguagem reconhecida por $A$ com a linguagem reconhecida por $B$ : $L (A \cup B) = L (A) \cup L (B) .$

Continuando com os autómatos do exemplo acima: $A \cup B = ({0, 1, 2, 3, I, F}, {a, b}, {(0, a, 1), (2, b, 3), (I, λ, {1, 2}), (1, λ, F), (3, λ, F)}, I, {F}) .$

Exercício: Desenhe o diagrama do autómato $A \cup B$ acima.

Também a iteração segue o mesmo padrão:

Iteração de AFND. Sejam $A = (Q^{A}, Σ, δ^{A}, q_{I}^{A}, {q_{F}^{A}})$ um AFND bem preparado.

Então, a iteração de $A$ é o AFND $A^{*}$ , definido por $(Q^{A} \cup {q_{I}, q_{F}}, Σ, δ^{A^{*}}, q_{I}, {q_{F}})$ em que

$δ^{A^{*}} = δ^{A} \cup {(q_{I}, λ, {q_{I}^{A}, q_{F}}), (q_{F}^{A}, λ, {q_{I}^{A}, q_{F}})} .$

A linguagem reconhecida por $A^{*}$ é o fecho da linguagem reconhecida por $A$ : $L (A^{*}) = L (A)^{*} .$

Exercício: Usando os exemplos acima, explicite as transições de $A^{*}, A \cup B^{*}, B^{*} B \cup A B^{*}$ e desenhe os respetivos diagramas.

A composição, união e iteração de AFND bem preparados são semelhantes em termos de requisitos e resultados. Para a negação e interseção é preciso sair desse padrão.

Intuitivamente, pensando em termos de autómatos deterministas, uma palavra é aceite se a computação termina num estado final e rejeitada se termina num estado não final. Portanto, basta trocar os estados finais com os não finais para se definir a linguagem complementar.

Quanto à interseção, uma vez definida a negação e a união, basta lembrar que para conjuntos, $A \cap B = \overline{\overline{A} \cup \overline{B}}$ e a mesma igualdade é válida para as linguagens regulares. Mas este processo é pouco prático.

Começando pela negação, é importante destacar que se aplica a autómatos deterministas ao contrário do que foi feito para a concatenação, união e iteração.

Negação de AFD. Sejam $A = (Q^{A}, Σ, δ^{A}, q_{I}^{A}, F^{A})$ um AFD.

Então, a negação de $A$ é o AFND $\overline{A}$ , definido por $(Q^{A}, Σ, δ^{A}, q_{I}^{A}, Q^{A} ∖ F^{A})$ .

A linguagem reconhecida por $\overline{A}$ é o complementar da linguagem reconhecida por $A$ : $L (\overline{A}) = Σ^{*} ∖ L (A) .$

Um AFD e a sua negação

AFD para $a^{*}$

AFD para $Σ^{} ∖ L (a^{})$

Paralelismo

É relativamente simples definir um autómato determinista que processa em paralelo outros dois (ou mais) autómatos também deterministas. Melhor, este método é suficientemente simples e geral para ter várias aplicações incluindo a união e interseção de AFD.

Em geral,

Autómato Paralelo. sejam $A = (Q^{A}, Σ, δ^{A}, q_{I}^{A}, F^{A})$ e $B = (Q^{B}, Σ, δ^{B}, q_{I}^{B}, F^{B})$ dois AFD sobre o mesmo alfabeto, $Σ$ .

Seja $P_{F}^{A, B} = (Q^{C}, Σ, δ^{C}, q_{I}^{C}, F)$ o AFD tal que:

Estados de Controlo: $Q^{C} = Q^{A} \times Q^{B}$ , isto é: um estado de controlo de $C$ é um par ordenado com um estado de $A$ e um estado de $B$ .

Transição: $δ^{C} ((i^{A}, i^{B}), a) = (j^{A}, j^{B})$ em que $j^{A} = δ^{A} (i^{A}, a), j^{B} = δ^{B} (i^{B}, a)$ , isto é: a transição de um estado é feira componente a componente.

Estado Inicial: $q_{I}^{C} = (q_{I}^{A}, q_{I}^{B})$ , isto é: o estado inicial é o par de estados iniciais.

Estados Finais: $F \subseteq Q^{A} \times Q^{B}$ .

O conjunto dos estados finais fica como parâmetro porque proporciona uma grande flexibilidade aos autómatos paralelos. Por exemplo:

União: Sejam $A, B$ dois AFD com estados finais $F^{A}, F^{B}$ respetivamente. Fazendo $F = {(i^{A}, i^{B}) : i^{A} \in F^{A} \lor i^{B} \in F^{B}}$ tem-se $L (A) \cup L (B) = L (P_{F}^{A, B})$ . Note-se que uma palavra é aceite por $P_{F}^{A, B}$ se e só se é aceite por $A$ ou se é aceite por $B$ .
Interseção: Nas condições acima, seja $G = {(i^{A}, i^{B}) : i^{A} \in F^{A} \land i^{B} \in F^{B}}$ . Então $L (P_{G}^{A, B}) = L (A) \cap L (B)$ . Note-se que uma palavra é aceite por $P_{G}^{A, B}$ se e só se é aceite por $A$ e por $B$ .

Conclusão

Esta secção aprofundou o estudo dos AFD e AFND. Especificamente:

Mostram-se dois métodos para minimizar um dado AFD, de modo a obter-se um AFD equivalente com o menor número possível de estados.
Definiram-se as operações de concatenação, união e iteração de AFND, replicando as operações das ER.
Definiu-se a negação e composição paralela de AFD. Com o processamento paralelo de AFD ficou trivial definir as operações de união e a interseção de AFD.

O Problema Principal de ALP — Dada uma linguagem $A$ e uma palavra $p$ no mesmo alfabeto, determinar se $p \in A$ — continua em aberto. As expressões regulares e os autómatos finitos (deterministas e não deterministas) verificam duas das três condições fundamentais:

São computáveis (existe um algoritmo que recebe uma palavra e num número finito de passos "responde" se essa palavra está ou não na linguagem pretendida) e eficientes (um AFD processa uma palavra com $n$ símbolos em exatamente $n$ passos).
Além disso é (relativamente) simples encontrar ER, AFND, AFD equivalentes.

Resta verificar se as linguagens regulares são adequadas para definir as linguagens de programação.

O Pumping Lemma

Os limites das linguagens regulares.

Introdução

Nas secções anteriores avançou-se na resolução do Problema Principal de ALP — Dada uma linguagem $A$ e uma palavra $p$ no mesmo alfabeto, determinar se $p \in A$ — com linguagens regulares.

As expressões regulares e os autómatos finitos (deterministas e não deterministas) são computáveis e eficientes mas ainda falta saber se são adequadas isto é, suficientemente expressivas para definir qualquer linguagem de programação.

As expressões algébricas, de uma forma ou outra, estão presentes em quase todas as linguagens de programação. Uma expressão algébrica é uma palavra como, por exemplo, 2 * (3 + 4) em que certas sub-palavras representam números (2, 3, 4), outras representam operações (+, *) e outras definem a estrutura da expressão ((, )).

A estrutura de uma expressão pode ser visualizada por uma árvore:

Árvore de uma Expressão Algébrica

Forma Alternativa

Naturalmente, pretende-se que no lugar de 2, 3 e 4 possam estar outras expressões algébricas e que as operações incluam, pelo menos, - e /. Conforme as expressões ficam mais complexas, maior a necessidade e a importância dos parêntesis.

A estrutura de um programa é semelhante à estrutura de uma expressão algébrica: Organiza-se como uma árvore com certos vértices "recursivos". Em vez de números e operações, nas árvores dos programas os vértices têm instruções, expressões, diretivas, etc.

if x > 2:
    a = double(x)
    for i in range(a):
        a = a + i
else:
    a = 0

Árvore de um Fragmento de Programa

Uma propriedade importante das expressões algébricas é que "os parêntesis têm de estar equilibrados". Descartando os números e as operações, restam apenas os parêntesis e obtêm-se palavras como (), ()(), (())()(()()), que são "válidas" enquanto que as palavras )(, ()), etc devem ser rejeitadas.

A "linguagem dos parêntesis equilibrados" é um excelente teste às linguagens regulares:

Se for regular, as linguagens regulares são adequadas para definir as linguagens de programação. De facto, o LISP (ver a página na wikipédia) é uma linguagem de programação que usa parêntesis e pouco mais.
Se não for regular, as linguagens regulares não permitem representar árvores de estruturas sintáticas como as expressões algébricas ou os programas python. Nesse caso será necessário tentar outra abordagem para as linguagens de programação.

O problema que se coloca agora é o seguinte: Como saber se uma dada linguagem é, ou não, regular?

Consideremos alguns exemplos (sobre o alfabeto $Σ = {a, b}$ ):

$A = {a^{n} : n \geq 0} = L (a^{*})$ é regular.
$\overline{A} = Σ^{*} ∖ A$ também é regular porque é o complementar de uma linguagem regular (na secção anterior viu-se como fazer a negação de um AFD).
$B = {b^{n} : n \geq 0} = L (b^{*})$ também é regular, assim como são $A B, B A^{*} (A \cup \overline{B})$ , etc.

Neste casos o "exercício" é simples porque ou se encontra uma ER adequada ou são aplicados os resultados teóricos das secções anteriores para construir linguagens regulares.

Quanto a uma versão simples dos parêntesis equilibrados:

$E = {a^{n} b^{n} : n \geq 0} .$

As palavras de $E$ são $λ, ab, aabb, aaabbb, \dots, a^{91537} b^{91537}, \dots$ Esta linguagem é regular?

De facto, como se prova que uma linguagem não é regular? O problema é o seguinte: Supondo que $A$ é uma linguagem regular. Como se prova que $A$ é regular? Basta encontrar uma ER (ou AFD ou AFND), $x$ , adequada: $A = L (x)$ .

Mas, se $A$ não for regular nenhuma ER é adequada. É preciso outro método para provar que $A$ não é regular.

Entra o Pumping Lemma.

O Pumping Lemma

Uma observação muito simples:

Um AFD com $n$ estados, quando processa uma palavra com mais do que $n$ símbolos, tem de "passar" mais do que uma vez em alguns estados, porque há mais símbolos do que estados.

Por exemplo, um AFD para $a^{*}$ , ilustrado abaixo, tem exatamente dois estados.

AFD para $a^{*}$

Contando as entradas nos estados deste autómato:

Palavra	Comprimento	Entradas em $I$	Entradas em $E$
$λ$	0	0	0
$a$	1	1	0
...	...	...	...
$aaa$	3	3	0
$aab$	3	2	1
$aba$	3	1	2
$abb$	3	1	2
$baa$	3	0	3
$bab$	3	0	3
$bba$	3	0	3
$bbb$	3	0	3
...	...	...	...

Todas as palavras de comprimento $3$ entram mais do que uma vez em algum estado do autómato. Claramente, o mesmo acontece para palavras de comprimento $4, 5, \dots$

Em geral, seja $p$ uma palavra que entra duas (ou mais) vezes no estado $i$ . Então pode escrever-se $p = uv w$ em que:

$u$ é o prefixo de $p$ que entra pela primeira vez em $i$ .
$v$ é uma sub-palavra de $p$ que parte de $i$ e entra de novo em $i$ .
$w$ é o restante sufixo de $p$ .

Como (o caminho de) $v$ começa e termina em $i$ , a sub-palavra $v$ pode ser indefinidamente repetida, inclusivamente eliminada, que o estado final da computação não se altera. Isto é, o estado final para $p = p_{1} = uv w$ é o mesmo que para $p_{0} = u w, p_{2} = uvv w, \dots, p_{9375} = u v^{9375} w$ .

Se $p$ for aceite, também são $p_{0}, p_{1}, p_{2}, \dots$ . E, se $p$ for rejeitada, também são $p_{0}, p_{1}, p_{2}, \dots$

Formalmente:

Pumping Lemma. Seja $L$ uma linguagem regular e $k$ o número de estados de um AFD que a aceita.

Qualquer palavra $p \in L$ com $∣ p ∣ > k$ pode ser escrita como $p = uv w$ em que:

$∣ uv ∣ < k$ .

$∣ v ∣ > 0$ .

Para qualquer $n \geq 0$ também $u v^{n} w \in L$ .

O Pumping Lemma é uma propriedade de todas as linguagens regulares. Dito de outra forma,

Se as conclusões do Pumping Lemma levarem a uma contradição é porque as hipóteses do Pumping Lemma não se verificam. Especificamente: a linguagem considerada não pode ser regular.

Revisitando a linguagem simplificada dos parêntesis equilibrados, $E = {a^{m} b^{m} : m \geq 0}$ .

Supondo que $E$ é regular, também é aceite por um certo AFD.
Seja $k$ o número de estados desse AFD.
A palavra $p = a^{k} b^{k} \in E$ .
Pelo Pumping Lemma, como $∣ p ∣ > k$ então $p = uv w$ em que:
1. $∣ uv ∣ < k$ . Portanto, $uv$ só tem $a$ .
2. $∣ v ∣ > 0$ . Portanto $v$ tem pelo menos um $a$ e nenhum $b$ .
3. Para cada $n \geq 0$ também $p_{n} = u v^{n} w \in E$ .

Em $p_{n} = u v^{n} w$ , quando $v$ é repetido,o número de $a$ é alterado. Mas o número de $b$ continua a ser $k$ . Portanto, quando $n \neq = 1$ , o número de $a$ deixa de ser igual ao número de $b$ .

Isto é uma contradição. Por um lado, se $p_{n} = u v^{n} w \in E$ então tem o mesmo número de $a$ e de $b$ mas por outro, ao repetir $v$ , $p_{n}$ fica com um número diferente de $a$ e de $b$ .

Portanto a suposição inicial, de que a linguagem $E$ é regular, é falsa. A única conclusão possível é que $E$ não é uma linguagem regular.

O facto de $E$ não ser uma linguagem regular tem consequências profundas:

Primeiro, encontrou-se uma linguagem que não é regular.

Segundo, as linguagens regulares não são adequadas para definir linguagens de programação.

A incapacidade das linguagens regulares para definir a linguagem simplificada dos parêntesis equilibrados implica a incapacidade para definir as estruturas recursivas (como árvores) necessárias nas linguagens de programação.

Conclusão

O Pumping Lemma aplicado à linguagem $E = {a^{m} b^{m} : m \geq 0}$ mostra que as linguagens regulares não são adequadas para definir linguagens de programação.

Portanto, é necessária outra abordagem para resolver o Problema Principal de ALP — Dada uma linguagem $A$ e uma palavra $p$ no mesmo alfabeto, determinar se $p \in A$ de forma computável, acessível e adequada.

Nem tudo está perdido. De facto, os conceitos introduzidos até aqui, as ER, os AFD e os AFND, vão continuar presentes no resto do curso e nas suas aplicações. O que muda é a importância que têm: Perdem o título de "candidato preferido" e passam a "contribuição necessária".

O próximo capítulo define certas gramáticas formais que, como vai ser mostrado, generalizam as linguagens regulares e estão associadas aos autómatos de pilha, uma forma simples de autómato com memória ilimitada.

Autómatos Finitos — Exercícios

Os exercícios assinalados com "✓" serão resolvidos nas aulas práticas; Os assinalados com "†" têm elevada dificuldade. Todos os restantes devem ser resolvidos pelos alunos.

Autómatos Finitos — Exercícios

Autómatos Finitos Deterministas

Exercício 01

Para o AFD $A = ({q_{0}, q_{1}, q_{2}}, {a, b}, δ, q_{0}, {q_{2}})$ com a transição $δ$ dada pela tabela

$δ q_{0} q_{1} q_{2} a q_{0} q_{2} q_{2} b q_{1} q_{1} q_{0}$

Desenhe o diagrama de estados.
Escreva as computações de $A$ para as palavras $abaa$ e $bbbabb$ referindo se são, ou não, aceites.
Escreva uma expressão regular que represente a linguagem reconhecida por $A$ .

Exercício 02

AFD Exercício 02

Seja $A$ o AFD dado pelo diagrama acima.

Qual é o estado inicial, e quais são os estados finais?
As palavras $0001$ , $010101$ e $001110101101$ são aceites?
Que palavras de $(01)^{*}$ estão em $L (A)$ ?

Exercício 03

Seja $A = ({0, 1, 2}, {x, y}, {(0, x, 1), (0, y, 0), (1, x, 1), (1, y, 2), (2, x, 1), (2, y, 0)}, 0, {0})$ um AFD.

desenhe o diagrama de estados
✓ escreva uma expressão regular que represente a linguagem reconhecida por $A$
✓ repita a alínea anterior para o AFD $A^{'}$ que apenas difere de $A$ no conjunto dos estados de aceitação, que no caso de $A^{'}$ é ${0, 1}$

Exercício 04

Construa um autómato finito determinista que reconheça a linguagem das palavras...

sobre ${a, b, c}$ em que todos os $a$ 's precedem todos os $b$ 's que, por sua vez, precedem todos os $c$ 's (donde que todos os $a$ 's precedem todos os $c$ 's), podendo não haver nem $a$ 's, nem $b$ 's, nem $c$ 's.
sobre ${a, b}$ que não têm $aa$ como subpalavra.
sobre ${a, b, c}$ em que cada $b$ é seguido imediatamente por $cc$ .
não vazias sobre ${a, b}$ em que o número de $a$ 's é divisível por $3$ .

Exercício 05

Construa um autómato finito determinista que reconheça a linguagem da ER $(ab)^{*} (ba)^{*}$ .

Exercício 06

Calcule ER das linguagens reconhecidas pelos autómatos seguintes.


a)		b)

c)		d)

e)

Exercício 07

Encontre um AFD que aceite a linguagem das palavras em $(0 \cup 1)^{*}$ ...

com prefixo $01$ .
com subpalavra $00101$ .
expansões binárias dos naturais congruentes zero módulo $5$ .
com subpalavra $00$ e sufixo $01$ .
com subpalavra $00$ e não têm sufixo $01$ .
em que cada bloco de quatro letras consecutivas contém $01$ .

Exercício 08

Encontre um AFD que aceite a linguagem das palavras...

com prefixo $010$ .
com sufixo $101$ .
com subpalavra $010$ ou $101$ .
em que as últimas cinco letras têm três $0$ s.
$w$ tais que $∣ w ∣_{1} + 2 ∣ w ∣_{0}$ é múltiplo de cinco.
sobre o alfabeto ${1, 2, 3}$ onde a soma dos símbolos é múltiplo de cinco.

Computação Não Determinista

Exercício 09

Determine a linguagem (ER) dos AFND acima.


a)	b)	c)

Exercício 10

Considere a linguagem de todos os números inteiros sem sinal, escritos em base $3$ , em que o último algarismo ocorre anteriormente no número. Por exemplo, $1202$ e $00$ pertencem a esta linguagem, mas $1002$ e $1$ não. (Os números escritos em base $3$ só podem ter os algarismos $0, 1$ e $2$ .)

escreva uma expressão regular que a represente.
defina um autómato finito que a reconheça.
$†$ apresente um autómato finito determinista que a reconheça (Sugestão: tente construí-lo diretamente, sem recorrer a qualquer algoritmo).

Exercício 11

Considere o autómato definido no diagrama acima.

Calcule o $fecho ({0})$ e o $fecho ({1, 2, 3})$ .
Calcule $δ ({0}, 0)$ e $δ ({2, 3}, 1)$ .
Desenhe as árvores das computações de $011$ e $101$ , indicando se são aceites ou rejeitadas.

Exercício 12

Seja $A = ({0, 1, 2}, {a, b, c}, δ, 0, {1, 2})$ um autómato finito não determinista cuja função de transição é

$δ 012 a {0} b {1, 2} c {1} {1} λ {2}$

Construa um autómato finito determinista equivalente a $A$ , usando o algoritmo dado nas aulas, e apresente uma ER que represente a linguagem por ele reconhecida.

Exercício 13

✓ Repita o exercício anterior para o autómato finito não determinista $B = ({0, 1, 2, 3}, {m, n}, δ, 0, {1})$ cuja função de transição é

$δ 0123 m {1} {1, 3} n {2} {1, 3} {2} λ {1} {3}$

Exercício 14

✓ Considere a linguagem de todas as palavras sobre ${a, b}$ em que o antepenúltimo símbolo é $b$ .

defina um autómato finito (não determinista) que reconheça esta linguagem.
aplicando o algoritmo dado nas aulas, construa um autómato finito determinista equivalente ao autómato finito da alínea anterior.

Exercício 15

$†$ Repita o exercício anterior para a linguagem de todas as palavras sobre ${a, b}$ em que o terceiro e o antepenúltimo símbolos são $b$ . São exemplos de palavras que pertencem a esta linguagem as palavras $aababaa$ , $abbbbbbbb$ , $abba$ e $bbb$ .

Exercício 16

Sejam $A_{1} = (Q_{1}, T, δ_{1}, q_{01}, F_{1})$ e $A_{2} = (Q_{2}, T, δ_{2}, q_{02}, F_{2})$ dois autómatos finitos tais que $Q_{1}$ e $Q_{2}$ são disjuntos. Defina um autómato finito $B$ tal que $L (B) = L (A_{1}) \cup L (A_{2})$ .

Exercício 17

Defina um AFD equivalente ao AFND

$N = ({p, q, r}, {0, 1}, δ, p, {q, r})$

em que

$δ p q r 0 {p, q} \emptyset \emptyset 1 {p} {r} \emptyset$

Minimização e Composição de AFD

Exercício 18

✓ Aplicando o algoritmo dado nas aulas, construa o autómato finito determinista mínimo equivalente a $A = ({A, B, C, D, E, F}, {a, b}, δ, A, {B, D})$ , com a função de transição

$δ A B C D E F a B E D F F E b E C F C F F$

e apresente uma expressão regular que represente $L (A)$ .

Exercício 19

Considere o autómato finito não determinista $A = ({1, 2, 3, 4, 5}, {x, y}, δ, 1, {5})$ , com a função de transição

$δ 12345 x {1} \emptyset {3} \emptyset {5} y {1, 2} {3} {3, 4} {5} {5}$

construa o AFD equivalente a $A$ .
construa o AFD mínimo equivalente a $A$ .

Exercício 20

✓ Considere a linguagem representada por $(aaa)^{*}$ reunida com $(aa)^{*}$ .

defina um autómato finito (não determinista) que reconheça aquela linguagem.
construa um AFD equivalente ao autómato finito definido na alínea anterior.
construa um AFD mínimo equivalente ao AFD obtido na alínea anterior.

Exercício 21

Repita o exercício anterior para a linguagem das palavras sobre ${a, b, c}$ que têm $abab c$ como subpalavra.

Exercício 22

✓ Construa um AFND que aceita a linguagem das palavras

binárias com, pelo menos, três ocorrências de $010$ ;
binárias com subpalavras $010$ e $101$ ;
binárias (com subpalavra $010$ ou $101$ ) e (com sufixo $111$ ou $000$ );
binárias em que o $3 n$ -ésimo símbolo é $0$ , para $n \geq 1$ ;
binárias, de tamanho $3 n$ , e em que, para cada $1 \leq k \leq n$ , algum dos $3 k - 2$ , $3 k - 1$ ou $3 k$ -ésimo símbolo é $0$ ;
$0^{n} 1 0^{m} 1 0^{q}$ em que $q \equiv nm mod 3$ ;

Exercício 23

Encontre um AFND que aceite as palavras...

com prefixo $010$ ou sufixo $110$ .
com pelo menos, duas ocorrências de $01$ e sufixo $11$ .
$0^{n} 1 0^{m}$ em que $n \equiv m (mod 3)$ .

Exercício 24

Sejam $A_{1}$ e $A_{2}$ dois AFND. Encontre um AFND $A$ tal que $L (A) = L (A_{1}) L (A_{2})$ .
Seja $A$ um AFND. Encontre um AFND $B$ tal que $L (B) = L (A)^{*}$ .

Exercício 25

Seja $A = ({p, q, r, s}, {0, 1}, δ, p, {q, s})$ um AFND em que

$δ p q r s 0 {q, s} {r} {s} \emptyset 1 {q} {q, r} {p} {p}$

Construa um AFND que aceite a linguagem complementar de $L (A)$ .

Exercício 26

Construa um AFD que aceite a linguagem binária das palavras em que o quinto símbolo a partir do fim é $0$ .
Converta (simule) cada um dos AFND seguintes num AFD:
1. $N = ({p, q, r}, {0, 1}, δ, p, {q, r})$ com transição $δ p q r 0 p r \emptyset 1 pq \emptyset \emptyset$
2. Dados nos diagramas abaixo:

26.2 A	26.2 B	26.2 C

Exercício 27

Construa um AFD que aceite a linguagem das palavras que:

Contêm as sub-palavras $010$ e $101$ ;
Com sufixo $00$ ou $01$ ou $10$ (de duas maneiras);
Ou (contêm as sub-palavras $001$ e $110$ ) ou (não contêm nem $001$ nem $110$ );
A quarta letra a partir do fim, e a quarta letra a partir do princípio são ambas $0$ (nota: $0110$ e $10101$ estão nesta linguagem);

O Pumping Lemma

Exercício 28

Mostre que as seguintes linguagens não são regulares:

✓ $L = {1^{n} + 1^{m} = 1^{n + m} : n, m \geq 0}$ .
A linguagem das palavras capicua sobre ${a, b}$ .
$L = {a a^{n} b^{n} : n \geq 0}$ .
$L = {0^{n} 1^{n + 1} : n \geq 0}$ .
$L = {a^{n} c b^{n} : n \geq 0}$ .
$L = {a^{n} b^{m} : m > n \geq 0}$ .

Implementação

As indicações gerais para os exercícios de implementação são válidas aqui.

Uma Biblioteca para AFD

A biblioteca para AFD tem de verificar as condições indicadas a seguir.

Os estados são números inteiros, os símbolos de entrada são string e as palavras são listas de símbolos.
Represente. Um AFD é representado por uma estrutura de dados FSA (pode ser uma classe, uma struct, etc) com os seguintes atributos, que devem ser visíveis mas não modificáveis:
- initialState o estado inicial.
- finalStates o conjunto dos estados finais.
- delta uma lista de triplos (q, s, p) que define a transição $δ (q, s) = p$ .
Construção. Um AFD é construidos pela função/método makeFSA(t,i,f) em que:
- t é uma lista de triplos (q, s, p) como acima.
- i é o estado inicial.
- f é a lista dos estados finais.
Sanidade. A função wellFormed(fsa) ou fsa.wellFormed() testa se os atributos t,i,f do argumento definem, de facto, um AFD. Quais são essas condições?
Implemente. A função step(fsa, q, s) ou fsa.step(q, s) devolve o estado p quando fsa está no estado q e lê s.

Se não existe transição para (q, s) esta função devolve "não definido".

Em python "não definido" é None, em java/kotlin é null, em rust é Option::None, outras linguagens podem ou não definir "não definido" :D
Implemente. A função proc(fsa, q, w) ou fsa.proc(q, w) devolve o estado em que fsa termina se começar em q e ler a palavra w. Use o critério de step se a computação não continuar até ao fim.
Implemente. A função accepts(fsa, q, w) ou fsa.accepts(q, w), testa se w é aceite por fsa. Esta função deve devolver sempre um booleano.
Escrita. A função repr(fsa) ou fsa.repr() devolve uma string com várias linhas:
- A primeira linha tem o formato i <Q>; em que <Q> é o estado inicial.
- A segunda linha tem o formato f <Q1> ... <Qn>; em que os <Qi> são os estados finais.
- As restantes linhas têm o formato <Q> <S> <P>; para representar a transição $δ (q, s) = p$ do fsa. Deve existir uma linha destas para cada "aresta" do autómato.
- N.B. todas as linhas terminam em ";" e valores na mesma linha são separados por espaços.
† Leitura. A função parseFSA(s) tem como argumento uma string no formato acima e devolve o FSA correspondente. A leitura do argumento deve descartar carateres "espaço" (\n\r\t) mas com cuidado.
† Escrita. Consulte a documentação da linguagem dot usada para definir grafos. Implemente uma função reprDOT(fsa) ou fsa.reprDOT() para gerar um grafo numa string em dot.
† Sanidade. As funções repr e parseFSA devem ser "inversas" uma da outra, no sentido em que parseFSA(s).repr() == s e parseFSA(fsa.repr()) == fsa. Embora estas igualdades não sejam exatamente igualdades, nem fáceis de implementar, teste-as com alguns casos simples.

Gramáticas e Autómatos de Pilha

O Pumping Lemma aplicado à linguagem $E = {a^{m} b^{m} : m \geq 0}$ mostra que as linguagens regulares não são adequadas para definir linguagens de programação.

Neste capítulo definem-se certas gramáticas formais que generalizam as linguagens regulares e estão associadas aos autómatos de pilha, uma forma simples de autómato com memória ilimitada.

Gramáticas Independentes de Contexto

Uma especificação formal de linguagens mais capaz do que as expressões regulares.

Gramáticas Independentes de Contexto

Introdução

Nos capítulos anteriores desenvolveu-se, para as ER, AFD e AFND, um conjunto de técnicas computacionais eficientes, com vista a resolver o Problema Principal de ALP. Porém, com o Pumping Lemma, conclui-se que é necessária uma forma mais geral de definir linguagens.

As linguagens naturais têm uma certa estrutura que resulta de regras gramaticais. Por exemplo, "O gato bebe leite." é válida em português mas "bebe. gato leite O" não. (N.B: neste exemplo os símbolos do alfabeto são as palavras da língua portuguesa — por exemplo, de um dicionário — e as palavras são sequências desses símbolos.)

Como descrever essas regras gramaticais? Por exemplo:

Frase       : Sujeito Predicado
Sujeito     : Artigo Substantivo
Predicado   : Verbo Advérbio
Artigo      : "o"
            | "as"
Substantivo : "gato"
            | "galinhas"
Verbo       : "bebe"
            | "voam"
Advérbio    : "devagar"
            | "baixinho"

Os termos Assim são variáveis e "entre aspas" são terminais.

Aplicando estas regras, obtém-se, por exemplo:

Frase   : Sujeito Predicado
        : Artigo Substantivo Predicado
        : o Substantivo Predicado
        : o gato Predicado
        : o gato Verbo Advérbio
        : o gato bebe Advérbio
        : o gato bebe devagar

Também se obtêm frases com pouco sentido, como as gato voam devagar. Esses problemas, em princípio, podem ser tratados com regras mais sofisticadas. No entanto, também este exemplo sem sentido mantém a estrutura entre as diferentes partes da palavra: o Artigo está no início, etc. Isto é, usando aquelas regras nunca se obtém, por exemplo, devagar bebe o gato.

Gramáticas e Linguagens Independentes de Contexto

As Gramáticas Independentes do Contexto são uma forma simples de representar rigorosamente regras gramaticais como as ilustradas acima.

Gramática Independente do Contexto (GIC). Uma Gramática Independente do Contexto é um tuplo $G = (V, Σ, P, S)$ em que:

Variáveis (ou Não Terminais): $V$ é um conjunto de símbolos, designados variáveis ou não terminais.

Terminais: $Σ$ é um conjunto de símbolos, disjunto de $V$ (isto é, $V \cap Σ = \emptyset$ ), designados terminais.

Produções (ou Regras): $P \subset V \times (V \cup Σ)^{*}$ é um conjunto finito. Os seus elementos são pares da forma $(A, p)$ com $A \in V$ e $p \in (V \cup Σ)^{*}$ , designados produções ou regras e denotados $A \to p$ .

Símbolo Inicial: $S \in V$ .

Numa GIC há dois tipos de símbolos: Os terminais, sem produções associadas e as variáveis, com produções associadas. Intuitivamente, as variáveis vão ser sucessivamente transformadas, até restarem apenas símbolos terminais.

É importante notar que o alfabeto das palavras é $(V \cup Σ)^{*}$ isto é, as palavras têm terminais e variáveis.

Esta mistura justifica a definição seguinte:

Prefixo (resp. Sufixo) Terminal. Seja $p \in (V \cup Σ)^{*}$ uma palavra formada por (zero ou mais) terminais e (zero ou mais) variáveis. Então, escrevendo $p = u q v$ em que $u, v \in Σ^{*}$ e $q$ começa e termina por variáveis.

O prefixo terminal de $p$ é $u$ .

O sufixo terminal de $p$ é $v$ .

Isto é, $u$ é o maior prefixo só de terminais de $p$ e $v$ é o maior sufixo só de terminais.

Por exemplo, em $p = ab S a B$ o prefixo terminal é $ab$ e o sufixo terminal é $λ$ .

A aplicação de regras de uma GIC transforma palavras. Formalmente:

Derivação. Sejam $G = (V, Σ, P, S)$ uma GIC, $u, v \in (V \cup Σ)^{*}$ .

Se $A \to p \in P$ , então $u A v$ deriva diretamente $u w v$ e escreve-se $u A v \Rightarrow u p v$ .

Se existem $p_{0}, p_{1}, \dots, p_{n} \in (V \cup Σ)^{*}$ tais que $p = p_{0} \Rightarrow p_{1} \Rightarrow \dots \Rightarrow p_{n} = q$ então $p$ deriva $q$ em $n$ passos e escreve-se $p \Rightarrow n q$ .

Se existe $n$ tal que $p \Rightarrow n q$ então $p$ deriva $q$ e escreve-se $p \Rightarrow * q$ .

As regras de uma gramática são aplicadas às variáveis de uma palavra e o resultado é uma nova palavra. A esse processo chama-se "derivação direta". Se forem aplicadas $n$ derivações diretas obtém-se uma "derivação em $n$ passos". Por fim, se o número exato de passos não for importante, tem-se uma "derivação".

Por exemplo, dada a gramática $G = ({S, A}, {a, b}, {S \to b A b, S \to b, A \to AA a, A \to λ}, S)$ :

$ab S b A b \Rightarrow ab S bb$ pela regra $A \to λ$ .
Também $ab S b A b \Rightarrow abbb A b$ pela regra $S \to b$ .
$ab S b A b \Rightarrow abb A bb A b$ pela regra $S \to b A b$ .

Em certas circunstâncias é necessário especificar a GIC de onde estão a ser usadas as derivações. Nesse caso acrescenta-se o índice $_{G}$ e a notação das derivações fica $p \Rightarrow_{G} q, p \Rightarrow n_{G} q, p \Rightarrow *_{G} q$ para indicar que são usadas apenas produções de $G$ .

Para escrever uma GIC é comum usarem-se as seguintes regras para simplificar a notação:

Os terminais são representados por minúsculas e as variáveis por maiúsculas.
Se nada for dito, $S$ é o símbolo inicial.
As produções de cada variável ficam agrupadas e, entre si, separadas por " $∣$ ".

Por exemplo, a gramática acima fica completamente definida por $S A \to b A b ∣ b \to AA a ∣ λ$

As produções de uma gramática transformam palavras noutras palavras. Essa transformação tem a designação técnica de derivação e é a base para associar uma linguagem a uma GIC.

Linguagem Gerada. Seja $C = (V, Σ, P, S)$ uma GIC.

O conjunto das palavras deriváveis a partir de $p \in (V \cup Σ)^{*}$ é $D (p) = {q : p \Rightarrow^{*} q}$ .

A linguagem gerada por $G$ é $L (G) = {t \in Σ^{*} : S \Rightarrow * t}$ .

Neste caso diz-se que $L (G)$ é uma Linguagem Independente do Contexto.

Duas gramáticas são equivalentes se geram a mesma linguagem.

Observação. As palavras da linguagem gerada são só de terminais. Isto é: $L (G) \subseteq Σ^{*}$ .

Tal como foi feito para as ER, os AFD e AFND, a equivalência entre GIC assenta na linguagem associada.

Por exemplo, qual é a linguagem gerada por $G = S \to a S b ∣ λ$ ?

Da produção $S \to λ$ resulta a derivação $S \Rightarrow * λ$ . Portanto $λ \in L (G)$ .
Da derivação $S \Rightarrow S \to a S b a S b \Rightarrow S \to λ ab$ resulta que $ab \in L (G)$ .
Igualmente, de $S \Rightarrow S \to a S b a S b \Rightarrow S \to a S b aa S bb \Rightarrow S \to λ aabb$ conclui-se que $aabb \in L (G)$ .
Sucessivamente, $aaabbb, a^{4} b^{4}, \dots, a^{m} b^{m}, \dots \in L (G)$ .

Portanto, $G = S \to a S b ∣ λ$ gera a linguagem simplificada dos parêntesis equilibrados, $E = {a^{m} b^{m} : m \geq 0}$ .

A linguagem $E$ , usada para mostrar que as linguagens recursivas não são adequadas para definir linguagens de programação é a linguagem gerada por uma GIC com apenas duas produções.

Este exemplo é um sinal positivo para resolução do Problema Principal de ALP, pelo menos em termos da adequação. Falta ainda aprofundar casos mais complexos de adequação e tratar dos aspetos da computação e da eficiência.

Recursividade

Donde vem a capacidade das GIC para gerar tão facilmente $E$ , quando as ER falharam?

Olhando de novo para a GIC em questão, $G = S \to a S b ∣ λ$ , destaca-se a regra $S \to a S b$ . O " $S$ " em " $a S b$ " permite "repetir indefinidamente" o $S$ , como um ciclo.

Esta possibilidade de "repetições indefinidamente" está além da capacidade expressiva das ER. Porém, é uma espada de dois gumes, que levanta problemas novos. Por exemplo, que palavras são geradas pela GIC $S \to S a$ ?

Formalmente, a produção $S \to a S b$ é "diretamente recursiva" e a recursão pode surgir de várias formas:

Produção Recursiva. Não Terminal Recursivo, Derivação Recursiva. Sejam $G = (V, Σ, P, S)$ uma GIC, $A \in V$ e $p, u, v \in (V \cup Σ)^{*}$ .

Uma produção da forma $A \to u A v$ é diretamente recursiva.

Uma variável $A$ é recursiva se $A \to p \Rightarrow * u A v$ (isto é, $A \Rightarrow * u A v$ em um ou mais passos).

Uma derivação da forma $A \Rightarrow * p \Rightarrow * u A v$ onde $A$ não ocorre em $p$ é indiretamente recursiva.

Por exemplo,

$S \to a S b$ é uma produção diretamente recursiva.
No exemplo anterior, $S$ é uma variável recursiva.
Na gramática $S \to a A b, A \to c S c ∣ λ$ , a derivação $S \Rightarrow a A b \Rightarrow a c S c b$ é indiretamente recursiva.

Mais tarde serão tratadas várias situações relacionadas com a recursividade mas por enquanto importa aprofundar mais aspetos das derivações.

Em primeiro lugar importa assegurar que, numa derivação $p \Rightarrow n q$ , as sub-derivações de uma variável em $p$ não são afetadas pelas sub-derivações de outras variáveis também em $p$ .

Por exemplo, supondo que numa certa CIG $a X bY c \Rightarrow 7 a ccc baaa c$ , é intuitivamente evidente que os $ccc$ resultam de $X$ e apenas de $X$ e que os $aaa$ resultam apenas do $Y$ e que, no total, fizeram-se $7$ derivações.

Mas a evidência intuitiva precisa de um apoio rigoroso:

Independência das Sub-Derivações. Seja $G = (V, Σ, P, S)^{*}$ uma GIC e $p \Rightarrow n q$ uma derivação em $G$ onde

$p = p_{1} A_{1} p_{2} A_{2} \dots p_{k} A_{k} p_{k + 1}$

com os $p_{i} \in Σ^{*}$ (portanto, palavras só de terminais) e os $A_{i} \in V$ .

Então existem palavras $q_{i} \in (V \cup Σ)^{*}$ tais que:

Para cada $i$ , $A_{i} \Rightarrow n_{i} q_{i}$ .

$q = p_{1} q_{1} p_{2} q_{2} \dots p_{k} q_{k} p_{k + 1}$ .

$\sum_{i = 1}^{k} n_{i} = n$ .

A independência está na afirmação de que o resultado $q = p_{1} q_{1} p_{2} q_{2} \dots p_{k} q_{k} p_{k + 1}$ é obtido isoladamente em cada variável, $A_{i} \Rightarrow n_{i} q_{i}$ .

Por exemplo, dada a gramática $S \to c A c B c, A \to a A ∣ λ, B \to B b ∣ λ$ , a derivação em $5$ passos $p c A c B c \Rightarrow c \underline{a A} c B c \Rightarrow c \underline{a} c B c \Rightarrow c a c \underline{B b} c \Rightarrow c a c \underline{B bb} c \Rightarrow q c a c \underline{bb} c$ tem sub-derivações:

$A \Rightarrow a A \Rightarrow a$ com dois passos; $A = A_{1} \Rightarrow 2 a = q_{1}$ .
$B \Rightarrow B b \Rightarrow B bb \Rightarrow bb$ com três passos; $B = A_{2} \Rightarrow 3 bb = q_{2}$
$q = c q_{1} c q_{2} c$ .

Derivação Esquerda/Direita

Considerando a GIC $S \to SS ∣ a S b ∣ λ$ , a partir do símbolo inicial, $S$ , há três opções para "escolher a produção". Se a escolha for $S \to SS$ , fica-se com a derivação $S \Rightarrow SS$ , se for $S \to a S b$ a derivação é $S \Rightarrow a S b$ e também $S \Rightarrow λ$ é uma derivação possível.

Em $SS$ há duas opções para "escolher a variável". A primeira $S$ ou a segunda? Se for a primeira, obtém-se $a S b S$ , $SSS$ e $S$ mas se for a segunda os resultados possíveis são $SSS$ , $S a S b$ e $S$ .

As regras das derivações permitem duas escolhas:

Que variável substituir?

Com que produção dessa variável?

Se por um lado estas escolhas permitem "capacidade expressiva" (o que é bom: as ER não são suficientemente expressivas) por outro lado as escolhas têm um custo elevado (exponencial) na eficiência computacional de futuros algoritmos sobre CIG e LIC.

Uma boa solução para este dilema restringe as escolhas sem sacrificar a "capacidade expressiva".

Derivação Esquerda. Derivação Direita.

Numa derivação esquerda é escolhida a variável mais à esquerda em todos os passos. Nas derivações esquerdas o símbolo $\Rightarrow$ é substituído por $\Rightarrow_{L}$ .

Numa derivação direita é escolhida a variável mais à direita em todos os passos. Nas derivações direitas o símbolo $\Rightarrow$ é substituído por $\Rightarrow_{R}$ .

Seja $G = (V, Σ, P, S)$ uma GIC. Para cada $p \in Σ^{*}$ , $p \in L (G) ⟺ S \Rightarrow * p ⟺ S \Rightarrow_{L} * p ⟺ S \Rightarrow_{R} * p .$

Isto é, numa derivação esquerda escolhe-se sempre a primeira variável e numa derivação direita escolhe-se sempre a última. A "capacidade expressiva" não fica prejudicada porque qualquer palavra só de terminais que seja gerada pela GIC também é gerada por uma derivação esquerda e também é gerada por uma derivação direita.

Por exemplo, continuando com a gramática $S \to SS ∣ a S b ∣ λ$ , como derivar $abaabb$ ?

Sem restrições, uma solução é $S \Rightarrow SS \Rightarrow a S b S \Rightarrow a S ba S b \Rightarrow aba S b \Rightarrow abaa S bb \Rightarrow abaabb$ . Nuns passos foi escolhida a primeira variável, noutros a última.
Derivação esquerda: $S \Rightarrow_{L} SS \Rightarrow_{L} a S b S \Rightarrow_{L} ab S \Rightarrow_{L} aba S b \Rightarrow_{L} abaa S bb \Rightarrow_{L} abaabb$ .
Derivação direita: $S \Rightarrow_{R} SS \Rightarrow_{R} S a S b \Rightarrow_{R} S aa S bb \Rightarrow_{R} S aabb \Rightarrow_{R} a S baabb \Rightarrow_{R} abaabb$ .

Árvore de Derivação

As derivações podem ser representadas graficamente por diagramas em árvore.

Árvore de Derivação. Seja $G = (V, Σ, P, S)$ uma GIC e $S \Rightarrow * p$ uma derivação de $G$ .

A árvore da derivação $S \Rightarrow * p$ é formada por:

Raiz: O símbolo inicial $S$ .

Filhos: Se a produção $A \to x_{1} x_{2} \dots x_{n}$ , com $x_{i} \in V \cup Σ$ for a produção usada para substituir a variável $A$ então o vértice $A$ tem filhos $x_{1}, x_{2}, \dots x_{n}$ por essa ordem.

Folhas Vazias: Se $A \to λ$ for a produção usada para substituir a variável $A$ então o vértice $A$ tem $λ$ como único filho.

Uma palavra $p$ tem árvore de derivação $T$ se $p$ for a concatenação das folhas de $T$ lidas da esquerda para a direita.

Por exemplo, a derivação $S \Rightarrow S \to a S b a S b \Rightarrow S \to a S b aa S bb \Rightarrow S \to λ aabb$ tem a seguinte árvore:

Exemplo de Árvore de Derivação

Lendo as folhas da esquerda para a direita obtém-se $aabb$ , a palavra derivada.

Ambiguidade

Um problema (ver Dangling Else na wikipedia) que ocorre frequentemente em várias linguagens de programação, e que é responsável por erros difíceis de detetar e com consequências graves, pode ser ilustrado no seguinte exemplo:

if (a) if (b) s1; else s2;

Este fragmento tanto pode ser tratado como

if (a) {
    if (b) s1;
    else s2;
}

ou como

if (a) {
    if (b) s1;
}
else s2;

No primeiro caso, se a for falso não corre nem s1 nem s2. No segundo caso, se a for falso corre s2. O que acontece se a for "inimigo detetado", s2 "lançar mísseis" e b testa "cenário simulado"?

Este problema resulta diretamente da gramática porque a palavra if (a) if (b) s1; else s2; tem duas derivações diferentes, uma que associa o else ao primeiro if e outra que o associa ao segundo.

Formalmente,

Gramática Ambígua. Linguagem Inerentemente Ambígua.

Uma gramática $G$ é ambígua se alguma palavra de $L (G)$ tem:

duas árvores de derivação distintas ou

duas derivações esquerdas distintas ou

duas derivações direitas distintas.

Uma linguagem é inerentemente ambígua se não for gerada por uma gramática não ambígua.

Nesta definição é importante lembrar e distinguir o seguinte:

Uma linguagem pode ser gerada por várias gramáticas equivalentes. Algumas dessas gramáticas podem ser ambíguas e outras não. Por isso, "ambígua" é uma propriedade que diz respeito às gramáticas.
Também pode acontecer que todas as gramáticas que geram uma certa linguagem sejam ambíguas. Esta situação é uma caraterística da linguagem, não das gramáticas que a geram. Por isso "inerentemente ambígua" é uma propriedade que diz respeito às linguagens.

Um exemplo de uma linguagem inerentemente ambígua é:

${a^{i} b^{j} c^{k} : i, j, k \geq 0}$

A gramática $S \to SS ∣ λ$ é ambígua porque $S \Rightarrow_{R} λ$ e $S \Rightarrow_{R} SS \Rightarrow_{R} S \Rightarrow_{R} λ$ são duas derivações direitas de $λ$ . Esta gramática é equivalente a $S \to λ$ que não é ambígua (exercício: porquê?).

Como é que as LIC se relacionam com as LR? O que foi feito nos capítulos anteriores está "perdido" ou as GIC estendem as ER?

Gramáticas Regulares e Simulação de AFND

Como definir linguagens regulares com GIC?

Gramática Regular. Uma gramática $G = (V, Σ, P, S)$ é regular se todas as suas produções têm uma das formas seguintes: $A A A \to a \to a B \to λ$ com $A, B \in V$ e $a \in Σ$ .

O interesse desta definição é que

Se $G$ é uma GIC regular então $L (G)$ é uma linguagem regular.

A demonstração desta afirmação está fora do âmbito de ALP. A consequência das gramáticas regulares é que as GIC podem gerar algumas linguagens regulares*. Será que podem gerar todas?

Simulação de AFND por GIC. Seja $A = (Q, Σ, δ, q_{I}, F)$ um AFND. A GIC equivalente a $A$ é $G = (V, Σ, P, S)$ em que:

variáveis - estados. $V = {X_{q} : q \in Q}$ .

símbolo inicial - estado inicial. $S = X_{q_{I}}$ .

produções - estados finais. Se $q \in F$ então $X_{q} \to λ \in P$ .

produções - transições $q ⟶ a p$ . Para cada $a \in Σ$ , se $p \in δ (q, a)$ então $X_{q} \to a X_{p} \in P$ .

produções - transições $q ⟶ λ p$ . Se $p \in δ (q, λ)$ então $X_{q} \to X_{p} \in P$ .

Neste caso $L (A) = L (G)$ .

Dado um AFND qualquer, aplicando este método, obtém-se uma GIC equivalente no sentido em que a linguagem aceite pelo AFND é gerada pela GIC. Portanto as LIC incluem todas as LR.

Por exemplo, dado o AFND antes usado para ilustrar o Algoritmo de Kleene:

AFND equivalente a $(λ \cup a) (b \cup b (a \cup b)^{} a)^{}$

vai construir-se a GIC em que:

As variáveis são $X_{0}, X_{1}, X_{2}, X_{3}$ .
O símbolo inicial é $S = X_{0}$ .
As transições e os estados finais definem as seguintes produções: $X_{0} X_{1} X_{2} X_{3} \to a X_{1} ∣ b X_{2} ∣ X_{1} \to b X_{1} ∣ b X_{3} ∣ λ \to X_{3} \to a X_{1} ∣ a X_{3} ∣ b X_{2}$

A palavra abaabb é aceite pelo AFND, pela computação

$0 ⊢ a 1 ⊢ b 3 ⊢ a 3 ⊢ a 1 ⊢ b 1 ⊢ b 1 \in F .$

Será gerada pela GIC? $X_{0} \Rightarrow a X_{1} \Rightarrow ab X_{3} \Rightarrow aba X_{3} \Rightarrow abaa X_{1} \Rightarrow abaab X_{1} \Rightarrow abaabb X_{1} \Rightarrow abaabb .$

Este exemplo também ilustra como a produção $X_{q} \to a X_{p}$ da GIC representa a transição $q ⊢ a p$ do AFND.

Conclusão

As GIC foram introduzidas depois de se ter constatado, no capítulo anterior, que as linguagens regulares são insuficientes para definir as linguagens de programação.

Logo um dos primeiros exemplos de GIC permitiu definir a linguagem simplificada dos parêntesis equilibrados, o que é um indicador positivo para as GIC.
Outro exemplo, as expressões algébricas, permitiu ilustrar como tratar o problema da ambiguidade.
A questão da relação entre as LR e as LIC ficou resolvida com a simulação de AFND por uma GIC regular.

Embora as GIC pareçam um candidato razoável para descrever as linguagens de programação, falta tratar as questões da computação: Como responder algoritmicamente, de forma eficiente, à questão $p \in L (G)$ ?

Autómatos de Pilha

Um modelo computacional simples com memória ilimitada.

Autómatos de Pilha

Introdução

Embora as GIC pareçam um candidato razoável para descrever as linguagens de programação, falta tratar as questões da computação: Como responder algoritmicamente, de forma eficiente, à questão $p \in L (G)$ ?

Intuitivamente, nos AFD e AFND a "memória" está representada pelos estados e portanto é limitada à priori, independentemente da palavra que vai ser processada. Por isso é que a linguagem $E = {a^{m} b^{m} : m \geq 0}$ "escapa" ao reconhecimento pelos AFD e AFND — "é preciso memorizar quantos $a$ foram lidos" e esse número é arbitrariamente grande.

As "pilhas" são uma forma simples de "memória ilimitada". Numa pilha podem ser colocados e retirados símbolos no "topo". A transição depende não só do estado e do símbolo da palavra mas também do símbolo que está no topo da pilha.

Autómatos de Pilha e Gramáticas Independentes de Contexto

Tal como foi feito para os AFD e AFND, depois da definição de autómato segue-se a configuração e computação e palavra aceite e linguagem reconhecida.

Autómato de Pilha (AP). Um Autómato de Pilha (AP) é um tuplo $A = (Q, Σ, Γ, δ, q_{I}, F)$ em que:

Estados de Controlo, Alfabeto de Entrada, Estado Inicial, Estados Finais $Q, Σ, q_{I}, F$ são como nos AFD.

Alfabeto da Pilha $Γ$ é um conjunto finito de símbolos.

Transição $δ$ é uma função com assinatura

$δ : Q \times (Σ \cup {λ}) \times (Γ \cup {λ}) \to P (Q \times (Γ \cup {λ}))$

Importa notar o seguinte:

A transição depende do estado de controlo, do símbolo de entrada e do símbolo no "topo" da pilha e define o novo estado de controlo e o novo símbolo no "topo" da pilha.

As computações dos AP são não deterministas, como resulta da assinatura da transição, na parte " $P (\dots)$ ". Formalmente:

Configuração. Computação. (AP). Seja $A = (Q, Σ, Γ, δ, q_{I}, F)$ um AP.

Uma Configuração é um triplo $(i, p, α) \in Q \times Σ^{*} \times Γ^{*}$ .

A Configuração Inicial para $p \in Σ^{*}$ é $(q_{I}, p, λ)$ .

Uma Computação é uma sequência de passos dos seguintes tipos:

AFND $(i, a p, λ) ⊢ (j, p, λ)$ se $(j, λ) \in δ (i, a, λ)$ e $p \in Σ^{*}$ .

Remove $(i, a p, A α) ⊢ (j, p, α)$ se $(j, λ) \in δ (i, a, A)$ e $p \in Σ^{*}$ .

Acrescenta $(i, a p, α) ⊢ (j, p, A α)$ se $(j, A) \in δ (i, a, λ)$ e $p \in Σ^{*}$ .

Troca $(i, a p, A α) ⊢ (j, p, B α)$ se $(j, B) \in δ (i, a, A)$ e $p \in Σ^{*}$ .

Informalmente, os tipos de passos de uma computação são

Tipo	Anterior	Seguinte	Condição	Observação
AFND	$(i, a p, λ)$	$(j, p, λ)$	$(j, λ) \in δ (i, a, λ)$	A pilha não é "usada".
Remove	$(i, a p, A α)$	$(j, p, α)$	$(j, λ) \in δ (i, a, A)$	$A$ no topo é substituído por $λ$ .
Acrescenta	$(i, a p, α)$	$(j, p, A α)$	$(j, A) \in δ (i, a, λ)$	$λ$ no topo é substituído por $A$ .
Troca	$(i, a p, A α)$	$(j, p, B α)$	$(j, B) \in δ (i, a, A)$	$A$ no topo é substituído por $B$ .

O critério de aceitação de uma palavra depende da configuração final.

Palavra Aceite. Linguagem Reconhecida. (AP) Seja $A = (Q, Σ, Γ, δ, q_{I}, F)$ um AP. A palavra $p \in Σ^{*}$ é aceite por $A$ se existe uma computação $(q_{I}, p, λ) ⊢ * (q, λ, λ), q \in F .$

A linguagem reconhecida (ou aceite) por $A$ é o conjunto das palavras aceites por $A$ .

A condição $(q, λ, λ), q \in F$ especifica que:

A computação chegou a um estado final,
Todos os símbolos de $p$ foram processados e
A pilha está vazia.

Além disso, a condição de aceitação depende de existir uma computação naquelas condições. Outras computações podem não ser assim. Portanto, para uma palavra ser rejeitada é necessário que nenhuma computação verifique todas.

Diagramas de AP

Os diagramas dos AP seguem as mesmas regras dos AFD e AFND, sendo apenas necessário indicar as operações na pilha.

Por exemplo, o AP por

Estados de Controlo $Q = {0, 1}$ .
Alfabeto de Entrada $Σ = {a, b}$ .
Alfabeto da Pilha $Γ = {X}$ .
Estado Inicial $q_{I} = 0$ .
Estados Finais $F = {1}$ .
Transição

$q 0 f 1 a, λ 0, X a, X b, λ b, X 1, λ λ, λ 1, λ λ, X$

tem o seguinte diagrama

Diagrama de AP para ${a^{m} b^{m} : m \geq 0}$

Note-se que na tabela da transição as colunas descrevem não só todas as possibilidades $Σ \times Γ$ como também os casos com $λ$ .

Descrevendo os passos das computações por $i, a p, A α ⊢ a, A / B j, p, B α$ algumas computações deste AP são:

De $λ$ : $0, λ, λ ⊢ λ, λ / λ 1, λ, λ$ . Como $1$ é final e a entrada e a pilha estão vazias, $λ$ é aceite.
De $a$ :
1. $0, a, λ ⊢ a, λ / X 0, λ, X ⊢ λ, λ / λ 1, λ, X$ . Esta computação poderia ter parado em $0, λ, X$ , que não aceita $a$ tal como a última configuração.
2. Em alternativa, $0, a, λ ⊢ λ, λ / λ 1, a, λ$ que não aceita $a$ .
3. Como não há mais computações de $a$ esta palavra é rejeitada.
De $b$ : $0, b, λ ⊢ λ, λ / λ 1, b, λ$ é a única possibilidade e rejeita $b$ .
De $ab$ : $0, ab, λ ⊢ a, λ / X 0, b, X ⊢ λ, λ / λ 1, b, X ⊢ b, X / λ 1, λ, λ$ aceita.
De $ba$ : é semelhante à computação de $b$ .

A computação de $ab$ ilustra bem o uso da pilha como dispositivo de memória. Por cada $a$ lido da entrada é acrescentado uma "conta" $X$ à pilha. Quando se passa do estado $0$ para $1$ cada $b$ desconta a "conta" do topo. Se o número de $b$ for igual ao número de $a$ então no fim de processar todos os $b$ a pilha fica vazia.

Aquele AP tem mais "estrutura" do que apenas a contagem de $a$ e $b$ . Por exemplo, $ba$ tem um $a$ e um $b$ mas é rejeitada devido à forma como o AP proíbe ler $a$ depois de começar a ler $b$ .

Árvore das Computações

As computações dos AP, em geral, não são deterministas. Isto significa que, dada uma palavra para processar, o AP "gera uma árvore", em vez de uma única sequência.

Árvore das Computações. Seja $A = (Q, Σ, Γ, δ, q_{I}, F)$ um AP e $p \in Σ^{*}$ . A árvore das computações de $p$ por $A$ é formada por:

Raíz: A configuração $(q_{I}, p, λ)$ .

Filhos: Se $v$ for um vértice da árvore, para cada configuração $u$ tal que $v ⊢ u$ por $A$ então $u$ é um filho de $v$ .

Por exemplo, no AP acima, a palavra $aabb$ tem a seguinte árvore de computação:

Árvore das Computações de $aabb$	Autómato de Pilha

Variantes de AP

O tipo de transições permitidas pela definição de AP é um caso intermédio entre:

Autómato Atómico é um AP que só tem transições do tipo
- $(j, λ) \in δ (i, a, λ)$ : AFND.
- $(j, λ) \in δ (i, λ, A)$ : Remove, mas não lê da entrada.
- $(j, A) \in δ (i, λ, λ)$ : Acrescenta, mas não lê da entrada.
Autómato Estendido é um AP que também permite transições do tipo $(j, β α) \in δ (i, a, A α)$ em que o topo da pilha é substituído por mais do que um símbolo ( $A / β$ ).

Estas variantes são equivalentes, no sentido em que um AP de uma variante pode ser transformado num AP doutra.

GIC e AP

Os AP definem o aspeto computacional das CIG mas essa ligação ainda não foi definida:

Simulação de GIC por AP. Seja $G = (V, Σ, P, S)$ uma GIC.

O AP $A = ({q}, Σ, Σ \cup V, δ, q, {q})$ em que a transição é definida por

Para cada variável $A \in V$ ,

$δ (q, λ, A) = {(q, p) : A \to p \in P}$

Para cada terminal $a \in Σ$ ,

$δ (q, a, a) = {(q, λ)}$

é equivalente a $G$ no sentido em que $L (G) = L (A)$ se a pilha for iniciada com $S$ .

Esta definição/transformação/teorema define como obter um AP equivalente a uma GIC dada. Embora o processo inverso fique fora do âmbito de ALP, para os efeitos pretendidos isto é suficiente.

Embora a condição sobre a inicialização da pilha contradiga a definição de AP, pode ser facilmente contornada. Basta definir um novo estado inicial $q_{I}$ e acrescentar a transição $δ (q_{I}, λ, λ) = {(q, λ, S)}$ .

Por exemplo, dada a GIC $S \to a S b ∣ λ$ o AP equivalente é

AP da GIC $S \to a S b ∣ λ$

As arestas associadas aos terminais e a cada variável são normalmente agrupadas de forma a facilitar a leitura do diagrama.

Este AP é equivalente ao anterior e à GIC da linguagem simplificada dos parêntesis equilibrados. Neste caso as produções da GIC podem ser "lidas" diretamente das arestas do AP.

Algumas computações deste AP:

De $λ$ : $q_{I}, λ, λ ⊢ λ, λ / S q, λ, S ⊢ λ, S / λ q, λ, λ$ aceita.
De $a$ :
1. $q_{I}, a, λ ⊢ λ, λ / S q, a, S ⊢ λ, S / λ q, a, λ$ . não aceita.
2. $q_{I}, a, λ ⊢ λ, λ / S q, a, S ⊢ λ, S / a S b q, a, a S b ⊢ a, a / λ q, λ, S b ⊢ λ, S / λ q, λ, b$ . não aceita.
3. $q_{I}, a, λ ⊢ λ, λ / S q, a, S ⊢ λ, S / a S b q, a, a S b ⊢ a, a / λ q, λ, S b ⊢ λ, S / a S b q, λ, a S bb$ . não aceita.
4. Não há mais computações de $a$ , que é rejeitada.
De $ab$ : $q_{I}, ab, λ ⊢ λ, λ / S q, ab, S ⊢ λ, S / a S b q, ab, a S b ⊢ a, a / λ q, b, S b ⊢ λ, S / λ q, b, b ⊢ b, b / λ q, λ, λ$ aceita.

A derivação de uma palavra na GIC é replicada na computação do AP.

Por exemplo, a palavra $ab$ tem a seguinte derivação: $S \Rightarrow S \to a S b a S b \Rightarrow S \to λ ab$ A mesma palavra tem a seguinte computação: $q_{I}, ab, λ ⊢ λ, λ / S q, ab, S ⊢ λ, S / a S b q, ab, a S b ⊢ a, a / λ q, b, S b ⊢ λ, S / λ q, b, b ⊢ b, b / λ q, λ, λ$

Hierarquia de Chomsky

As GIC não são o único tipo de gramática:

Tipo 0 ou sem restrições as produções são da forma $p \to q$ em que $p \in (V \cup Σ)^{+}$ e $q \in (V \cup Σ)^{*}$ . Isto é, o lado esquerdo pode ser qualquer palavra não vazia. A substituição de um símbolo depende da "vizinhança" desse símbolo, o seu contexto.
Tipo 1 ou dependente de contexto são como as de tipo 0 mas $∣ p ∣ \leq ∣ q ∣$ . Tal como no Tipo 0 a substituição de símbolos depende do contexto mas, adicionalmente, as substituições contraem a palavra.
Tipo 2 ou independente de contexto são as gramáticas usadas aqui. A substituição de um símbolo não depende do contexto em que este ocorre.
Tipo 3 ou regular impõe ainda mais restrições às produções e geram as linguagens regulares.

Conclusão

Os AP são um modelo computacional das GIC. Especificamente, há um algoritmo que transforma uma GIC num AP equivalente. Além disso, as derivações na GIC são replicadas pelas computações do AP.

Ficam assim resolvidas as questões da adequação e da computação no Problema Principal de ALP — Dada uma linguagem $A$ e uma palavra $p$ no mesmo alfabeto, determinar se $p \in A$ .

Falta ainda tratar da eficiência. Os AP não são deterministas e, ao contrário dos AFND, não se conhece nenhuma simulação determinista que seja geral e eficiente. A esperança que resta é condicionar as gramáticas de forma a que os AP associados sejam, em termos práticos, deterministas mas sem estragar a "capacidade expressiva" das gramáticas.

O próximo capítulo começa por visitar os principais tipos de Análise Sintática (o termo técnico do Principal Problema de ALP) e segue para métodos e tipos de gramáticas adequados à sua resolução eficiente.

Exercícios — Gramáticas e Autómatos de Pilha

Os exercícios assinalados com "✓" serão resolvidos nas aulas práticas; Os assinalados com "†" têm elevada dificuldade. Todos os restantes devem ser resolvidos pelos alunos.

Exercícios — Gramáticas e Autómatos de Pilha

Gramáticas Independentes do Contexto

Exercício 01

Escolha três ou quatro linguagens de programação (como C, python, Java ou outras mais recentes como go ou swift) ou apenas formais (como o XML) e encontre (online) gramáticas que as definam.

Exercício 02

Defina uma gramática independente do contexto que gere a linguagem:

${w c w^{R} : w \in {a, b}^{*}}$ .
${w c^{n} : w \in {a, b}^{*} e n = ∣ w ∣}$ .
${a^{i} b^{j} c^{k} : k \geq 0 e i + j = k}$ .
✓ ${a^{n} b^{m} : m, n \geq 0 e m \neq = n}$ .
dos números naturais sem zeros não significativos.

Exercício 03

Defina uma gramática independente do contexto que gere os reais (incluindo os negativos) em que: a parte inteira é não vazia e não tem zeros não significativos; a parte decimal é não vazia e só termina em zero se for constituída por um único 0; e as partes inteira e decimal são separadas por uma vírgula.

Exercício 04

✓ Seja $L$ a linguagem de todas sequências de parêntesis, curvos - ‘ $($ ’ e ‘ $)$ ’ - e rectos - ‘ $[$ ’ e ‘ $]$ ’ -, bem emparelhados. Pertencem a esta linguagem palavras como $λ$ , “ $()$ ”, “ $[]$ ”, “ $() [()]$ ”, “ $([()])$ ” e “ $([] [([])]) []$ ”. Não pertencem a $L$ palavras como “ $]$ ”, “ $($ ”, “ $(]$ ”, “ $([)]$ ”, “ $) ($ ” e “ $[()]]$ ”.

Mostre que $L$ não é regular;
Defina uma gramática independente do contexto que gere $L$ .

Exercício 05

✓ Considere um conjunto $V$ de variáveis e um conjunto $F$ de símbolos de função, cada um com uma aridade maior que ou igual a zero. Um termo é definido como:

uma variável é um termo.
um símbolo de função de aridade 0 é um termo.1
se $t_{1}, t_{2}, \dots, t_{k}, k > 0$ são termos, então, para todos os símbolos de função $f$ de aridade $k$ , $f (t_{1}, t_{2}, \dots, t_{k})$ é um termo;
nada mais é um termo.

Defina uma gramática independente do contexto que gere os termos descritos — use os símbolos $v$ e $f$ como representantes das variáveis e dos símbolos de função, respetivamente. Exemplos de termos são $v$ , $f$ , $f (v)$ e $f (v, f (f (f), f))$ .

Exercício 06

Considere a gramática $G = ({A}, {a, b}, {A \to AA ∣ a A b ∣ λ}, A)$ .

Construa uma derivação esquerda para a palavra $aababb$ e a respetiva árvore de derivação.
Construa uma derivação direita para a palavra $ababab$ e a respetiva árvore de derivação.
Determine se G é ambígua. † Em caso afirmativo, apresente uma gramática não ambígua equivalente.

Exercício 07

✓ Considere a gramática independente do contexto $G = ({S}, {a}, {S \to aa ∣ SS}, S) .$

Mostre que esta gramática é ambígua.
† Apresente uma gramática equivalente não ambígua.
Apresente uma gramática regular equivalente.
Apresente uma expressão regular que represente a linguagem gerada pela gramática.

Exercício 08

Resolva o exercício anterior para a gramática $G = ({S, A}, {a}, {S \to λ ∣ A S, A \to λ ∣ a}, S) .$

Exercício 09

Defina uma gramática livre do contexto que gere a linguagem …

${0^{2 k} 1^{k - 1} : k \geq 1}$ . Usando essa gramática, derive a palavra $00001$ .
${1^{2 k + 1} 0^{k} : k \geq 0}$ . Usando essa gramática, derive a palavra $1110$ .

Exercício 10

† Defina uma gramática livre do contexto que gere todas a expressões regulares sobre o alfabeto ${a, b}$ .

Exercício 11

Considere a gramática livre do contexto $S \to a S aa ∣ B; B \to bb B cc ∣ C; C \to b c$

Derive $a^{3} b^{3} c^{3} a^{6}$ .
† Mostre que esta gramática é não ambígua.

Exercício 12

Considere a gramática livre do contexto $S \to A a S b B ∣ λ; A \to a A ∣ a; B \to b B ∣ λ$ ;

Mostre que esta gramática é ambígua.
Encontre uma gramática equivalente, não ambígua.

Autómatos de Pilha

Exercício 13

✓ Defina um autómato finito que reconheça a linguagem gerada pela gramática $S \to 01 S ∣0 S ∣11∣1$ .

Exercício 14

✓ Defina um autómato de pilha que reconheça a linguagem ${w : w \in {a, b}^{*} e w = w^{R}}$ . Será possível definir um autómato de pilha determinista que reconheça esta linguagem? Justifique a sua resposta.

Exercício 15

✓ Considere a linguagem de todas as palavras sobre ${a, b}$ em que o número de $a$ é igual ao número de $b$ :

${p \in {a, b}^{*} : ∣ p ∣_{a} = ∣ p ∣_{b}}$

defina um autómato de pilha não determinista que a reconheça.
† defina um autómato de pilha determinista que a reconheça.

Exercício 16

Defina um autómato de pilha que reconheça $L = {1^{n} + 1^{m} = 1^{m + n} : n, m \geq 0}$ e indique se esse autómato é, ou não, determinista.

Exercício 17

Defina um autómato de pilha que reconheça $L = {a^{2 n} b^{3 n} : n \geq 0}$ .

Exercício 18

Construa um autómato de pilha que reconheça a linguagem das expressões aritméticas com o operador $+$ e com parêntesis. Use o símbolo $n$ para representar os operandos atómicos, i.e., as expressões terão o seguinte aspeto: $n$ , $n + n$ , $(n + (n + (n))) + n$ , etc.

Implementação

As indicações gerais para os exercícios de implementação são válidas aqui.

Uma biblioteca para GIC e AP

Para esta biblioteca são adotadas as seguintes convenções e orientações:

Um símbolo é uma string válida: uma string não vazia em que não ocorre ' '.
Uma variável é um símbolo que começa por uma maiúscula.
Um terminal é um símbolo que não é uma variável.
Estão implementadas funções is_symbol(s), is_variable(s) e is_terminal(s).
Uma palavra é uma lista de símbolos.
As regras são representadas pela classe Rule, com:
1. O construtor Rule(var, word).
2. Os métodos básicos variables(), terminals(), equals(other).
3. Os métodos analíticos is_nil(), is_recursive(), is_wellformed().
4. Os métodos operacionais dderive_left(word), dderive_right(word).
5. O método auxiliar __repr__() com "→" para a seta e usando "λ" quando adequado.
6. A função auxiliar parse_grammar(s). Assume-se que s é uma string com os símbolos separados por espaços, que o primeiro desses símbolos define o lado esquerdo da regra e os restantes a palavra do lado direito. Por exemplo, "A a A b" define a regra A→aAb.
As gramáticas são representadas pela classe Grammar, com:
1. O construtor Grammar(rules).
2. Os métodos básicos variables(), terminals(), rules_of(symbol) e set_start(symbol).
3. Os métodos analíticos is_wellformed(), start() (o símbolo inicial), is_nil(symbol), nil_symbols(), is_recursive(symbol), recursive_symbols().
4. Os métodos operacionais derive_left(sequence, word), derive_right(sequence, word) onde sequence é uma lista com indíces das regras e word é um parâmetro opcional com valor por omissão igual ao símbolo inicial da gramática (start()).
5. O método auxiliar __repr__().
6. A função auxiliar parse_grammar(s). Assume-se que s é uma string com blocos de regras separados por ';' e em que cada bloco de regras é da forma V : P1 | P2 | ...| Pn. Por exemplo "S:a A b|;A:S|c" define a gramática $S \to a A b ∣ λ; A \to S ∣ c$ . Note bem que as regras de uma variável podem estar "espalhadas" por vários blocos e que eventuais repetições de regras devem ser descartadas.
O símbolo inicial (start) de uma gramática é calculado da seguinte forma:
1. Se for usado o método set_start(symbol) é o valor do parâmetro symbol.
2. Caso contrário, se 'S' é uma variável na gramática ou se a gramática tem zero regras, o símbolo inicial é 'S'.
3. Por fim, se nenhuma das outras situações se verifica, é o lado esquerdo da primeira regra da gramática.
As linhas das transições, $(q_{1}, s_{1}) \in δ (q_{0}, a, s_{0})$ , são representadas pela classe TrLine, com:
1. O construtor TrLine(state_0, symbol, stack_0, state_1, stack_1) onde (state_0, symbol, stack_0, state_1, stack_1) é $(q_{0}, a, s_{0}, q_{1}, s_{1})$ .
As configurações, $(q, p, s)$ , são representadas pela classe Configuration, com:
1. O construtor Configuration(state, tape, stack) onde (state, tape, stack) é $(q, p, s)$ .
2. Os métodos analíticos is_final(final_symbols), is_fitting(trline) e all_fitting(transition).
3. Os métodos operacionais next(trline, check) e tree(delta, max_depth, check) em que check é um parâmetro opcional que por omissão vale False e, sendo verdadeiro, ativa a verificação is_fitting(trline). Note bem que o resultado de aplicar uma linha a uma configuração incompatível é a configuração inicial.

Exercício 19

Sempre que possível teste a sua biblioteca com as gramáticas e os autómatos dos exercícios anteriores.

Análise Sintática

A Análise Sintática trata de relacionar uma palavra com uma gramática. Especificamente, pretende-se saber se a palavra é gerada pela gramática e, se sim, qual a sua derivação.

Portanto,

A Análise Sintática é uma versão do Problema Principal de ALP quando a linguagem é gerada por uma GIC.

No capítulo anterior definiram-se as gramáticas independentes de contexto e os autómatos de pilha, para ultrapassar os limites das linguagens regulares e dos autómatos finitos no que diz respeito à definição de linguagens de programação.

Ficaram assim resolvidas as necessidades sobre um esquema formal adequado para representar as linguagens de programação e dum modelo de computação para determinar se $p \in L (G)$ .

Mas mantém-se o problema da eficiência porque, embora os autómatos de pilha proporcionem um modelo computacional para as linguagens independentes de contexto, não se conhecem formas gerais para garantir que as suas computações sejam eficientes.

Restam duas possibilidades: Ou condicionar as gramáticas de forma a reduzir a ramificação durante as derivações ou "espreitar" os símbolos por processar para "guiar" as computações,

Este capítulo começa por visitar os principais métodos de pesquisa geral em grafos, de forma a avaliar o problema da eficiência nalguns casos concretos.

De seguida é primeiro apresentado um processo (sequência de passos) que permite transformar uma GIC noutra equivalente e melhor adaptada ao algoritmos de pesquisa geral (a Forma Normal de Greibach). Por fim são apresentadas as classes de gramáticas $LL$ e $L R$ , que "espreitam" os próximos símbolos "por processar" para definir algoritmos deterministas de análise sintática.

Análise Sintática

Pesquisar o Grafo de uma GIC ou uma Árvore das Computações de um AP de forma a encontrar a derivação de uma palavra e construir uma árvore de sintaxe abstrata.

Análise Sintática

Introdução

A eficiência computacional da análise sintática tem um problema, manifesto no não determinismo dos autómatos de pilha (que, ao contrário dos AFND, deles não se conhece nenhuma simulação determinista, geral e eficiente) e, equivalentemente, nas múltiplas produções das gramáticas independentes do contexto. Ambos estes casos têm representações gráficas: o Grafo da Gramática nas GIC e as Árvores das Computações nos AP.

Nesta situação é necessário fazerem-se pesquisas, abrangendo (no pior cenário) todas as possibilidades. Este é um processo inerentemente (demasiado) demorado pelo que importa encontrar formas de o melhorar.

Conteúdo

Do Problema Principal de ALP — Dada uma linguagem $L \subseteq Σ^{*}$ e uma palavra $p \in Σ^{*}$ , determinar se $p \in L$ . resta resolver a questão da eficiência computacional, já que a adequação ficou resolvida com as GIC e a computação com os AP.

Intuitivamente, para determinar se $p \in L$ usando um AP, $A$ , é necessário explorar a árvore das computações de $A$ com entrada $p$ . Especificamente:

O problema de determinar se $p \in L (G)$ pode ser resolvido por pesquisa na árvore das computações do AP $A$ .

Além disso, como os AP e as GIG são equivalentes, esta observação também sugere que

As derivações de uma GIC podem ser representadas por um grafo orientado.

Mais abaixo vai ser definida rigorosamente a representação das derivações da GIC por um grafo e como é que o problema $p \in L$ pode ser resolvido por pesquisa quer no grafo (das derivações) da GIC quer no grafo (das computações) do AP.

Entretanto, interessa fazer uma breve revisão sobre pesquisa em grafos orientados. O problema pode ser definido como:

Pesquisa em Grafos Orientados. Dado um grafo orientado, descobrir se existe algum caminho $v_{0} \to v_{1} \to \dots \to v_{n}$ desde um vértice inicial, $v_{0}$ , até um vértice final, $v_{n}$ .

A resolução geral deste problema segue o seguinte código:

def pesquisa(grafo, a, b):
  candidatos = [ a ]
  visitados = []
  while len(candidatos) > 0:
    candidato = candidatos.pop(0)
    visitados.append(candidato)
    if candidato == b:
      return True
    else:
      proximos = expande(grafo, candidato)
      proximos_novos = remove(proximos, visitados)
      candidatos = junta(candidatos, proximos_novos)
  return False

N.B. Este código é muito geral e, portanto, não otimizado. Melhorias significativas podem incluir, por exemplo, um resuldado mais descritivo, com o caminho de a até b.

Há quatro variantes da resolução geral deste problema, que correspondem às combinações da seguintes opções para expande e para junta:

Se expande(G, v) segue a direção das arestas — devolve os filhos de v em G — a pesquisa é descendente, com a = inicial e b = final.
Se expande(G, v) segue contra a direção das arestas — devolve os pais de v em G — a pesquisa é ascendente, com a = final e b = inicial.
Se junta(x, y) devolve x + y (x seguido de y) — a pesquisa é em largura.
Se junta(x, y) devolve y + x (y seguido de x) — a pesquisa é em profundidade.

Resumidamente:

`a`	`b`	`expande`	`junta(x, y)`	Pesquisa
$v_{0}$	$v_{n}$	filhos	`y + x`	Descendente Profundidade
$v_{0}$	$v_{n}$	filhos	`x + y`	Descendente Largura
$v_{n}$	$v_{0}$	pais	`y + x`	Ascendente Profundidade
$v_{n}$	$v_{0}$	pais	`x + y`	Ascendente Largura

A função remove exclui dos candidatos os vértices já visitados e não depende do tipo de pesquisa.

Grafo de uma Gramática

Todas as possíveis derivações de uma gramática podem ser organizadas num grafo orientado, que começa no símbolo inicial e "percorre" sucessivamente as produções aplicadas durante as derivações. Neste grafo "caminhos" diferentes representam derivações diferentes. Os vértices "são" as palavras intermédias e as arestas as produções aplicadas:

Grafo Esquerdo (resp. Direito) de uma GIC. Seja $G = (V, Σ, P, S)$ uma GIC. O grafo esquerdo de $G$ (resp. direito) é o digrafo com:

Vértices: as palavras do conjunto $N = {p \in (V \cup Σ)^{*} : S \Rightarrow_{L} * p}$ (resp. $S \Rightarrow_{R} * p$ ).

Arestas: os elementos de $A = {(a, b, p) \in N \times N \times P : a \Rightarrow_{L} p b}$ (resp. $a \Rightarrow_{R} p b$ ).

Por exemplo, para a GIC $S \to a S ∣ λ$ parte do grafo esquerdo é

Grafo Esquerdo de $S \to a S ∣ λ$ (parcial)

O grafo (esquerdo/direito) de uma GIC representa todas as possíveis derivações (esquerdas/direitas) dessa GIC. Este grafo não tem de ser uma árvore porque no grafo de uma gramática ambígua há vários "caminhos" para o mesmo vértice.

Exemplo/Exercício: Desenhe o grafo de $S \to a S ∣ S a ∣ λ$ .

As árvores e as gramáticas não ambíguas estão relacionadas:

O grafo esquerdo (resp. direito) de uma GIC não ambígua é uma árvore. Recíprocamente, se o grafo esquerdo (resp. direito) de uma GIC for uma árvore, então a GIC é não ambígua.

O grafo da GIC não deve ser confundido com as árvores de derivação, que ilustram uma possível derivação de uma palavra.

Qualquer palavra de terminais gerada pela GIC é um vértice sem filhos. Isto é, $G \Rightarrow * p \in Σ^{*}$ se, e só se, $p$ é um vértice sem filhos no grafo de $G$ .

Isto é a reformulação do Problema Principal de ALP como um problema de pesquisa em grafos: Dada uma GIC $G = (V, Σ, P, S)$ e uma palavra $p \in Σ^{*}$ , existe algum caminho $S ⟶ p$ no grafo (esquerdo) de $G$ ? Nesse caso $p \in L (G)$ ; caso contrário $p \neq \in L (G)$ .

Exemplos com Expressões Algébricas Simplificadas

Para ilustrar melhor os grafos esquerdos e direitos, assim como os algoritmos de pesquisa, considere-se a seguinte gramática, para expressões algébricas simplificadas (EAS):

$EAS : {S U \to U ∣ S + U \to a ∣ b$

Os inícios dos grafos (esquerdo e direito) são

Grafo Esquerdo de EAS	Grafo Direito de EAS

Portanto, para já, a análise sintática pode ser feita em oito tipos de pesquisa:

Direção	Estratégia	Grafo
Descendente	Largura	Grafo da GIC
Descendente	Largura	Árvore das Computações do AP
Descendente	Profundidade	Grafo da GIC
Descendente	Profundidade	Árvore das Computações do AP
Ascendente	Largura	Grafo da GIC
Ascendente	Largura	Árvore das Computações do AP
Ascendente	Profundidade	Grafo da GIC
Ascendente	Profundidade	Árvore das Computações do AP

Análise Sintática Descendente em Largura no Grafo da GIC

Intuitivamente, mantém-se uma lista de candidatos, iniciada com $S$ e aplicam-se sucessivamente produções, sempre ao primeiro elemento dessa lista, o "candidato". Há três hipóteses:

O candidato é o alvo ou não há candidatos. A pesquisa termina.
O candidato é incompatível com o alvo. Passa-se ao próximo candidato.
O candidato é compatível com o alvo, mas diferente. Os filhos do candidato atual são acrescentados ao fim da lista.

Compatível significa que o prefixo terminal do candidato é um prefixo do alvo.

Por exemplo, nas EAS, a pesquisa DL de $b + a$ é:

$S U S + U a b U + U S + U + U a + U b + U U + U + U ⋮ b + a,,,,,,,,,, S + U a, b b, U + U, S + U + U U + U, S + U + U S + U + U a + U, b + U b + U, U + U + U, S + U + U + U U + U + U, S + U + U + U, a + a, a + b S + U + U + U, a + a, a + b, b + a, b + b \dots$

Análise Sintática Descendente em Profundidade no Grafo da GIC

Intuitivamente, mantém-se uma lista de candidatos, iniciada com $S$ e aplicam-se sucessivamente produções, sempre ao primeiro elemento dessa lista, o "candidato". Há três hipóteses:

O candidato é o alvo ou não há candidatos. A pesquisa termina.
O candidato é incompatível com o alvo. Passa-se ao próximo candidato.
O candidato é compatível com o alvo, mas diferente. Os filhos do candidato atual são acrescentados ao início da lista.

Por exemplo, nas EAS, a pesquisa DP de $b + a$ é:

$S U a b S + U U + U a + U b + U b + a,,,,,,, S + U b, S + U S + U S + U + U b + U, S + U + U S + U + U b + b, S + U + U$

Análise Sintática Ascendente e as Computações do AP

As pesquisas anteriores percorrem o grafo da gramática, gerado pelas suas produções. Por outro lado, os autómatos de pilha, sendo equivalentes às GIC, também podem ser usados para a análise sintática.

No caso dos AP o não determinismo ocorre sempre que uma configuração tem dois ou mais sucessores. Por outro lado a própria palavra proporciona informação que pode ser usada para guiar a pesquisa.

As computações nos AP "consomem" a palavra na entrada e este processo é semelhante às pesquisas ascendentes, que começam no "alvo" e "andam para trás" até chegarem a um vértice "inicial".

O processo de pesquisa nas computações é essencialmente descrito pelas operações de transferência e de redução de um certo AP derivado da GIC.

N.B. que este AP não foi ainda formalmente definido.

Intuitivamente, a palavra da entrada é passada para a pilha, transferindo um símbolo de cada vez. Também a palavra que está na pilha pode ser reduzida, isto é, "desfeito" o resultado de aplicar uma produção. No fim, a entrada deve ficar vazia e a pilha só com o símbolo inicial.

Redução é o inverso da aplicação de uma produção. Por exemplo, se $A \to c B c$ for uma produção então uma possível redução da palavra $bb c B c ab$ será $bb A ab$ porque $bb \underline{A} ab \Rightarrow A \to c B c bb \underline{c B c} ab$ .

Por exemplo, escolhendo convenientemente as operações "transferência", $T r$ , da entrada para a pilha e "redução", $R e d$ , duma subpalavra na pilha, uma computação possível de $b + a$ é

$pilha λ b U S S + S + a S + U S entrada b + a + a + a + a a λ λ λ opera \overset{c}{¸} \overset{a}{˜} o T r R e d R e d T r T r R e d R e d produ \overset{c}{¸} \overset{a}{˜} o U \to b S \to U U \to a S \to S + U$

Um resultado interessante deste método é que as reduções aplicadas mostram uma derivação direita da palavra, lida "de baixo para cima" na coluna "Produção":

$S \Rightarrow S \to S + U S + U \Rightarrow U \to a S + a \Rightarrow S \to U U + a \Rightarrow U \to b b + a$

Este esquema não só determina se a palavra é gerada pela gramática como, nesse caso, encontra uma derivação da palavra.

No entanto, tem algumas fontes de não determinismo:

Quando fazer uma redução ou uma transferência?

Numa redução podem ser escolhidos várias subpalavras da pilha e várias produções da gramática.

Por exemplo, dada a GIC $S \to a A ∣ b B, A \to a, B \to aa ∣ a$ como reduzir $baa$ na pilha? Pode escolher-se:

Subpalavra	Produção	Nova Pilha
$ba \underline{a}$	$A \to a$	$ba A$
$ba \underline{a}$	$B \to a$	$ba B$
$b \underline{a} a$	$A \to a$	$b A a$
$b \underline{a} a$	$B \to a$	$b B a$
$b \underline{aa}$	$B \to aa$	$b B$

Análise Sintática Ascendente em Largura

Intuitivamente, mantém-se uma lista de candidatos, iniciada com $p$ e aplicam-se todas as reduções possíveis, sempre ao primeiro elemento dessa lista, o "candidato". Há duas hipóteses:

O candidato é a produção inicial ou não há candidatos. A pesquisa termina.
O candidato admite reduções. Os pais desse candidato são acrescentados ao fim da lista.

Por exemplo, nas EAS, a pesquisa AL de $b + a$ é:

$b + a U + a b + U S + a U + U b + S S + U U + S S,,,,,,,, b + U S + a, U + U U + U, b + S, (U + U) b + S, S + U S + U, U + S, (S + U) U + S, (U + S) S, S + S S + S, (S + S)$

Análise Sintática Ascendente em Profundidade

Intuitivamente, mantém-se uma lista de candidatos, iniciada com $p$ e aplicam-se todas as reduções possíveis, sempre ao primeiro elemento dessa lista, o "candidato". Há duas hipóteses:

O candidato é a produção inicial ou não há candidatos. A pesquisa termina.
O candidato admite reduções. Os pais do candidato atual são acrescentados ao início da lista.

Por exemplo, nas EAS, a pesquisa AP de $b + a$ é:

$b + a U + a S + a S + U S,,,, b + U U + U, b + U U + U, b + U U + U, b + U$

Conclusão

Depois de resolvidas as questões da adequação e da computação, está-se a tratar da eficiência no Problema Principal de ALP/Análise Sintática.

A análise sintática é representada como um problema de pesquisa em grafos orientados que, em geral, pode ser resolvido por quatro estratégias diferentes: (ascendente ou descendente) x (largura ou profundidade). Por outro lado a pesquisa tanto pode ser feita no grafo da gramática como na árvore das computações do autómato de pilha.

Nenhuma destas estratégias gerais é eficiente. Para melhorar este problema e guiar as pesquisas na análise sintática colocam-se duas possibilidades: ou se condiciona a gramática, de forma reduzir as produções aplicáveis em cada passo ou, então, consultam-se os símbolos por processar para guiar as transições dos autómatos de pilha.

Formas Normais

Gramáticas Adaptadas para Análise Sintática por Pesquisa Geral.

Formas Normais

Introdução

A análise sintática é representada como um problema de pesquisa em grafos orientados que, em geral, pode ser resolvido por quatro estratégias diferentes: (ascendente ou descendente) x (largura ou profundidade). Nenhuma destas estratégias gerais é eficiente.

Nesta secção é apresentado um processo (a normalização de uma gramática) que, numa sequência de passos, transforma numa gramática noutra, equivalente, e adaptada (tanto quanto possível) aos algoritmos de pesquisa: uma forma normal.

Conteúdo

O bom funcionamento (mínimo número de passos) da pesquisa no grafo de uma GIC depende da própria gramática.

Problemas como:

Pesquisas infinitas quando a palavra não é derivada pela gramática.
Exploração repetida de ramos quando a gramática é ambígua.

reduzem significativamente o desempenho da pesquisa.

Em certos caso é possível transformar a gramática dada noutra equivalente mas que "favorece" a pesquisa, reduzindo o número de ramificações, desambiguando, e/ou detetando "cedo" se a palavra não é gerada pela gramática.

Esta secção descreve um processo algorítmico de transformação de gramáticas. No fim a gramática que se obtém proporciona pesquisas gerais mais eficientes.

Todo este processo vai ser ilustrado com um exemplo de uma GIC (especialmente desenhada) para ilustrar a aplicação de cada passo:

$G^{0} = ({L, M, N, O}, {a, b, c, d}, \dots, L) L M N O \to M b ∣ a L b ∣ λ \to L b ∣ M L N ∣ λ \to N a N ∣ N b O \to c O ∣ λ$

1. Símbolo Inicial Não Recursivo

A recursividade é a "vantagem" das GIC sobre as ER, mas é também, uma fonte de dificuldades. Embora não seja desejável, nem sequer possível, remover completamente a recursividade das produções de uma GIC esta pode ser, em certos casos, controlada.

Símbolo Inicial Não Recursivo. Seja $G = (V, Σ, P, S)$ uma GIC. Existe uma GIC $G^{'} = (V^{'}, Σ, P^{'}, S^{'})$ equivalente a $G$ e onde o símbolo inicial não é recursivo.

Porque:

Se o símbolo inicial de $G$ não for recursivo então $G^{'} = G$ .
Se o símbolo inicial de $G$ for recursivo então, fazendo $S^{'}$ uma variável nova:

$G^{'} = (V \cup {S^{'}}, Σ, P \cup {S^{'} \to S}, S^{'}) .$

Exemplo. Em $G^{0}$ o símbolo inicial é recursivo porque $L \to a L b$ é uma produção de $G^{0}$ . Portanto esta gramática é transformada em

$G^{1} = ({L^{'}, L, M, N, O}, {a, b, c, d}, \dots, L^{'}) L^{'} L M N O \to L \to M b ∣ a L b ∣ λ \to L b ∣ M L N ∣ λ \to N a N ∣ N b O \to c O ∣ λ$

Em $G^{1}$ o símbolo inicial já não é recursivo. Além disso, $L (G^{0}) = L (G^{1})$ .

2. Eliminação de Produções Vazias

Antes de tratar do segundo passo na normalização de uma gramática é necessário definir alguns conceitos e técnicas.

Quase todas as produções "aumentam" o tamanho da palavra. Por exemplo $A \to b B$ faz com que $a A a$ passe para $ab B a$ , isto é de comprimento três para quatro. E esta é uma propriedade desejável pois permite cortar "filhos demasiado grandes" durante a pesquisa.

Há duas exceções de nota: as produções vazias $A \to λ$ e as produções unitárias $A \to B$ . Formalmente:

Produções Vazias. Produções Unitárias. Gramática Contraível. Seja $G = (V, Σ, P, S)$ uma GIC.

Uma produção vazia tem a forma $A \to λ$ .

Uma produção unitária tem a forma $A \to B$ .

O conjunto dos geradores da palavra vazia é $Λ = {A \in V : A \Rightarrow * λ} .$

Numa gramática não contraível não existem geradores da palavra vazia. Isto é $Λ = \emptyset$ .

Numa gramática essencialmente não contraível o único gerador de vazio é o símbolo inicial. Isto é $Λ = {S}$ .

O interesse das gramáticas essencialmente não contraíveis é que:

Numa gramática essencialmente não contraível os passos intermédios de uma derivação só podem diminuir de tamanho por aplicação de $S \to λ$ .

Não é possível, nem desejável, descartar completamente os geradores de vazio. Por exemplo, se $λ \in L (G)$ então em qualquer gramática equivalente a $G$ tem de existir pelo menos uma produção vazia. Neste caso, o melhor que se pode fazer é "concentrar" todas as produções vazias em $S \to λ$ .

A transformação de uma gramática noutra equivalente envolve a introdução de novas produções e a substituição de uma produção por outras, de forma a manter a linguagem gerada.

Introdução de Produções. Substituição de Produções. Seja $G = (V, Σ, P, S)$ uma CIG.

Se $A \Rightarrow * u$ então $G^{'} = (V, Σ, P \cup {A \to u}, S)$ é equivalente a $G$ .

Se $A \to u B v \in P$ e $B \to w_{1} ∣ w_{2} ∣ \dots ∣ w_{n}$ são todas as produções de $B$ então a gramática $G^{'} = (V, Σ, P^{'}, S)$ em que $P^{'} = P ∖ {A \to u B v} \cup {A \to u w_{1} v ∣ u w_{2} v ∣ \dots ∣ u w_{n} v}$ é equivalente a $G$ .

Intuitivamente, estas duas regras permitem "saltar" passos intermédios numa derivação.

O primeiro passo para retirar as produções que reduzem o comprimento das palavras trata das produções vazias.

Eliminação de Produções Vazias. Sejam $G = (V, Σ, P, S)$ uma GIC em que o símbolo inicial não é recursivo. e $G^{'} = (V, Σ, P^{'}, S)$ em que as produções são, em conjunto:

As produções de $P$ que não são produções da palavra vazia.

A produção $S \to λ$ se $λ \in L (G)$ .

Todas as produções que se obtêm eliminando um ou mais símbolos de $Λ$ do corpo $w$ de cada produção $A \to w$ , desde que o resultado, $w^{'}$ , tenha pelo menos um símbolo.

Então $G^{'}$ é equivalente a $G$ e essencialmente não contraível.

Exemplo. Na gramática $G^{1}$ o símbolo inicial não é recursivo. Além disso, os seus geradores da palavra vazia são $Λ = {L^{'}, L, M, O} .$

A gramática $G^{2}$ , que resulta de $G^{1}$ por eliminação das produções vazias é:

$G^{2} = ({L^{'}, L, M, N, O}, {a, b, c, d}, \dots, L^{'}) L^{'} L M N O \to L ∣ λ \to M b ∣ b ∣ a L b ∣ ab ∣ λ \to L b ∣ b ∣ M L N ∣ L N ∣ MN ∣ N ∣ λ \to N a N ∣ N b O ∣ N b \to c O ∣ c ∣ λ$

Note-se que:

Foram retiradas as produções $L \to λ$ e $M \to λ$ .
Como $λ \in L (G^{1})$ , foi acrescentada $L^{'} \to λ$ .
De cada produção em cujo corpo ocorrem geradores da palavra vazia foram acrescentadas variantes sem esses símbolos. Por exemplo:
1. Em $L \to M b$ no corpo, $M b$ , ocorre $M \in Λ$ . Portanto é acrescentada a produção $L \to b$ , que resulta de $M b$ removendo $M$ .
2. Mais interessante, no corpo da produção $M \to M L N$ tanto $M$ como $L$ são geradores da palavra vazia. As combinações possíveis sem algum desses elementos são $L N, MN, N$ .

Sem os cálculos auxiliares:

$G^{2} = ({L^{'}, L, M, N, O}, {a, b, c, d}, \dots, L^{'}) L^{'} L M N O \to L ∣ λ \to M b ∣ b ∣ a L b ∣ ab \to L b ∣ b ∣ M L N ∣ L N ∣ MN ∣ N \to N a N ∣ N b O ∣ N b \to c O ∣ c$

3. Eliminação de Produções Unitárias

As produções unitárias substituem uma variável por outra variável e podem ser eliminadas usando cadeias.

Cadeia. Seja $G = (V, Σ, P, S)$ uma GIC essencialmente não contraível.

Para cada $A \in V$ , a cadeia de $A$ é o conjunto $cadeia (A) = {B \in V : A \Rightarrow * B}$ .

Qualquer gramática $G^{'} = (V, Σ, \dots, S)$ cujas produções $A \to w$ são tais que:

$w \neq \in V$ .

Existe $B \in cadeia (A)$ tal que $B \to w \in P$ .

é equivalente a $G$ .

Este enunciado pode ser difícil de interpretar. O primeiro ponto afirma que na gramática $G^{'}$ não existem produções unitárias. O segundo ponto permite substituir a produção unitária $A \to B$ por $A \to w$ para cada $B \to w$ .

Exemplo. As cadeias de $G^{2}$ são

$A \in V L^{'} L M N O cadeia (A) L^{'}, L L M, N N O$

e as produções unitária são $L^{'} \to L$ e $M \to N$ . As respetivas substituições são:

de $L^{'} \to L$ , dado que $L \to M b ∣ b ∣ a L b ∣ ab$ : $L^{'} \to M b ∣ b ∣ a L b ∣ ab$ .
de $M \to N$ , dado que $N \to N a N ∣ N b O ∣ N b$ : $M \to N a N ∣ N b O ∣ N b$ .

A gramática que se obtém, equivalente a $G^{2}$ , é:

$G^{3} = ({L^{'}, L, M, N, O}, {a, b, c, d}, \dots, L^{'}) L^{'} L M N O \to M b ∣ b ∣ a L b ∣ ab ∣ λ \to M b ∣ b ∣ a L b ∣ ab \to L b ∣ b ∣ M L N ∣ L N ∣ MN ∣ N a N ∣ N b O ∣ N b \to N a N ∣ N b O ∣ N b \to c O ∣ c$

4. Eliminação de Símbolos Inúteis

A definição de linguagem gerada pela GIC $G = (V, Σ, P, S)$ é $L (G) = {p \in Σ^{*} : S \Rightarrow * p}$

Uma inspeção rápida a $N \to N a N ∣ N b O ∣ N b$ mostra que a recursividade desta variável impede-a de gerar palavras só de terminais. Portanto, em termos de linguagem gerada, este é um símbolo que pode ser retirado da gramática. Também podem ser retirados os símbolos que não podem ser atingidos a partir do símbolo inicial.

Símbolo Útil. Símbolo Acessível. Gramática Limpa. Seja $G = (V, Σ, P, S)$ uma GIC.

Um símbolo $x \in V \cup Σ$ é:

Útil se existe uma derivação $S \Rightarrow * u x v \Rightarrow * p \in Σ^{*}$ .

Inútil se não é útil.

Acessível se existe uma derivação $S \Rightarrow * u x v$ .

Inacessível se não é acessível.

Uma variável $A \in V$ é:

Produtiva se $A \Rightarrow * p \in Σ^{*}$ .

Improdutiva se não é produtiva.

Uma variável é útil se e só se for acessível e produtiva.

Uma gramática sem símbolos inúteis e inacessíveis diz-se limpa (ou reduzida).

Para limpar uma gramática de símbolos inúteis e inacessíveis:

Eliminar as variáveis improdutivas:
1. Encontrar as variáveis produtivas (por exemplo, derivando delas uma palavra só de terminais).
2. Remover as produções onde ocorrem as variáveis improdutivas.
Eliminar as variáveis inacessíveis:
1. Encontrar os símbolos acessíveis (por exemplo, fazendo uma derivação a partir do símbolo inicial onde o símbolo ocorra).
2. Remover as produções das variáveis inacessíveis.

Exemplo. Como foi observado acima, $N$ é inútil. Portanto as produções onde $N$ ocorre podem ser removidas. As novas produções são:

$L^{'} L M N O \to M b ∣ b ∣ a L b ∣ ab ∣ λ \to M b ∣ b ∣ a L b ∣ ab \to L b ∣ b ∣ M L N ∣ L N ∣ MN ∣ N a N ∣ N b O ∣ N b \to N a N ∣ N b O ∣ N b \to c O ∣ c$

Como resultado destas remoções $O$ deixou de ser acessível: Nenhuma derivação $L^{'} \Rightarrow * \dots$ "contém" $O$ . Portanto, também as produções de $O$ podem ser removidas e o resultado é:

$G^{4} = ({L^{'}, L, M}, {a, b}, \dots, L^{'}) L^{'} L M \to M b ∣ b ∣ a L b ∣ ab ∣ λ \to M b ∣ b ∣ a L b ∣ ab \to L b ∣ b$

Note-se que, removendo as produções de $O$ , o terminal $c$ ficou inacessível, pelo que foi retirado de $Σ$ , tal como $d$ , que nunca constou nas produções.

Finalmente, é fácil de verificar que $L^{'}, L$ e $M$ são produtivos e acessíveis. Também $a$ e $b$ são acessíveis.

Numa gramática limpa todos os símbolos "contam". Além disso, e de se ter tratado das produções vazias e unitárias, pouco se fez para melhorar o processo de pesquisa no grafo da gramática. Para esse efeito é preciso "controlar a forma" das produções.

5. Forma Normal de Chomsky

O corpo das produções de uma CIG é uma palavra de $(V \cup Σ)^{*}$ , pelo que pode ter vários terminais e variáveis misturados. Aqui pretende-se "arrumar" as formas possíveis que as produções podem ter.

Forma Normal de Chomsky (FNC). Uma GIC $G = (V, Σ, P, S)$ está na forma normal de Chomsky se cada uma das suas produções tem uma das formas seguintes:

$A \to BC$ com $B, C \in V ∖ {S}$ .

$A \to a$ com $a \in Σ$ .

$S \to λ$ .

A forma normal de Chomsky é bastante fácil de obter, substituindo terminais "inconvenientes" por variáveis e usando novas variáveis para "agrupar" cadeias três ou mais símbolos.

Exemplo. Na gramática

$G^{4} = ({L^{'}, L, M}, {a, b}, \dots, L^{'}) L^{'} L M \to M b ∣ b ∣ a L b ∣ ab ∣ λ \to M b ∣ b ∣ a L b ∣ ab \to L b ∣ b$

acrescentam-se $A \to a$ e $B \to b$ para retirar estes terminais das outras produções: $L^{'} L M A B \to M B ∣ b ∣ A L B ∣ A B ∣ λ \to M B ∣ b ∣ A L B ∣ A B \to L B ∣ b \to a \to b$

Para se obter a FNC ainda falta tratar das produções $L^{'} \to A L B$ e $L \to A L B$ . Para tal acrescenta-se a produção $X \to L B$ e substitui-se $L^{'}, L \to A X$ . O resultado final é:

$G^{5} = ({L^{'}, L, M, A, B, X}, {a, b}, \dots, L^{'}) L^{'} L M A B X \to MB ∣ b ∣ A X ∣ A B ∣ λ \to MB ∣ b ∣ A X ∣ A B \to L B ∣ b \to a \to b \to L B$

6. Forma Normal de Greibach

Uma forma de reduzir o número de ramificações durante a pesquisa consiste em "olhar para o próximo símbolo" da palavra e escolher apenas produções que colocam esse símbolo no início.

Por exemplo, dadas a GIC $S \to a A ∣ b B; A \to a A ∣ λ; B \to b B ∣ λ$ e a palavra $aa$ , é simples de ver que a única derivação possível é $S \Rightarrow S \to a A a A \Rightarrow A \to a A aa A \Rightarrow A \to λ aa$ porque em cada passo há só um candidato possível.

Neste caso, em cada passo da pesquisa é muito simples descartar todos os candidatos que não começam pelo terminal correto. Esta observação motiva a seguinte definição:

Forma Normal de Greibach (FNG). Uma GIC $G = (V, Σ, P, S)$ está na forma normal de Greibach se cada uma das suas produções tem uma das formas seguintes:

$A \to a B_{1} B_{2} \dots B_{n}$ com $a \in Σ, B_{i} \in V ∖ {S}, i \in 1 \dots n$ .

$A \to a$ com $a \in Σ$ .

$S \to λ$ .

Note-se que, em relação à forma normal de Chomsky, a única diferença na primeira forma das produções: $A \to a B_{1} B_{2} \dots B_{n}$ em vez de $A \to BC$ .

As gramáticas na FNG são úteis para:

evitar recursões infinitas nos algoritmos de pesquisa.

guiar (com o primeiro símbolo) a escolha das regras a expandir.

produzir AP equivalente à gramática dada.

Construção de uma GIC na FNG

Ao contrário da construção da FNC, que é simples de obter, a construção de uma GIC na FNG requer alguma orientação.

Construção da FNG. Dada uma GIC $G = (V, Σ, P, S)$ na FNC:

Ordenar as variáveis. Define-se uma ordem total nas variáveis de $G$ com uma única condição: $S$ é o primeiro elemento.

Passo Descendente. Segue-se essa ordem para transformar todas as produções de modo que, se $A \to Bp, B \in V, p \in (V \cup Σ)^{*}$ então $A < B$ .

Passo Ascendente. Segue-se essa ordem invertida para substituir cada produção $A \to Bp$ por $A \to qp$ para cada produção $B \to q, q \in (V \cup Σ)^{*}$ .

Exemplo. Continuando com $G^{5}$ , que está na FNC:

$L^{'} L M A B X \to MB ∣ b ∣ A X ∣ A B ∣ λ \to MB ∣ b ∣ A X ∣ A B \to L B ∣ b \to a \to b \to L B$

Ordenar as variáveis. A única condição é " $L^{'}$ é o primeiro elemento". Por exemplo $L^{'} < X < B < A < L < M .$

Passo Descendente. Ordenar as produções seguindo essa ordem.

$L^{'} X B A L M \to MB ∣ b ∣ A X ∣ A B ∣ λ \to L B \to b \to a \to MB ∣ b ∣ A X ∣ A B \to L B ∣ b L < M, A X < L L < M; L \neq < A M \neq < L$

As produções de $L$ e de $M$ não verificam a condição do passo descendente. No caso de $L$ esse problema resolve-se facilmente substituindo o $A$ no início da produções de $L$ por $a$ (porque $A \to a$ ).

$L^{'} X B A L M \to MB ∣ b ∣ A X ∣ A B ∣ λ \to L B \to b \to a \to MB ∣ b ∣ \underline{a} X ∣ \underline{a} B \to L B ∣ b L < M, A X < L L < M M \neq < L$

Resta o problema com a produção $M \to L B$ . Segue-se também o método anterior:

$L^{'} X B A L M \to MB ∣ b ∣ A X ∣ A B ∣ λ \to L B \to b \to a \to MB ∣ b ∣ a X ∣ a B \to \underline{M B} B ∣ \underline{b} B ∣ \underline{a X} B ∣ \underline{a B} B ∣ b L < M, A X < L L < M M \neq < M$

Só que desta vez o problema não ficou resolvido e resultou numa Recursão Direta à Esquerda da variável $M$ .

Eliminação da Recursividade Direta à Esquerda. Se

$A \to A x_{1} ∣ \dots ∣ A x_{n} ∣ y_{1} ∣ \dots ∣ y_{m}$

são as produções de $A$ , organizadas de forma que:

Cada $A x_{1}, \dots, A x_{n}$ começa por $A$ e
Nenhuma $y_{1}, \dots, y_{m}$ começa por $A$ .

Então obtém-se uma gramática equivalente:

Acrescentando uma nova variável, por exemplo $Z$ .
Substituindo as produções de $A$ por

$A Z \to y_{1} Z ∣ \dots ∣ y_{m} Z ∣ y_{1} ∣ \dots ∣ y_{m} \to x_{1} Z ∣ \dots ∣ x_{n} Z ∣ x_{1} ∣ \dots ∣ x_{n}$

Uma mnemónica para este processo é a seguinte:

Substituir $A \to A x ∣ y$ por $A \to y Z ∣ y$ e $Z \to x Z ∣ x$ .

Intuitivamente percebe-se porque esta substituição é válida observando que a linguagem gerada por $A \to A x ∣ y$ é: $y, y x, y xx, y xxx, \dots, y x^{n}, \dots$

Agora, outra forma de descrever esta linguagem é "Um $y$ seguido de zero ou mais $x$ ." Neste caso:

$Z \to x Z ∣ x$ gera um ou mais $x$ .
$A \to y Z ∣ y$ gera um $y$ seguido de zero ou um $Z$ .

A eliminação da RDE de

$M A \to M A BB x_{1} ∣ b B y_{1} ∣ a XB y_{2} ∣ a BB y_{3} ∣ b y_{4}$

define as produções

$M Z \to b BZ ∣ a XBZ ∣ a BBZ ∣ b Z \to BBZ ∣ b B ∣ a XB ∣ a BB ∣ b ∣ BB$

pelo que a ordem inicialmente definida para as variáveis tem de ser estendida de forma que $Z < B$ . Por exemplo:

$L^{'} < X < Z < B < A < L < M .$

A nova gramática equivalente fica:

$L^{'} X Z B A L M \to MB ∣ b ∣ A X ∣ A B ∣ λ \to L B \to BBZ ∣ BB \to b \to a \to MB ∣ b ∣ a X ∣ a B \to b BZ ∣ a XBZ ∣ a BBZ ∣ b Z ∣ b B ∣ a XB ∣ a BB ∣ b L < M, A X < L Z < B L < M$

No fim do passo descendente cada produção ou é vazia ou começa por um terminal ou começa por uma variável "mais abaixo".

Passo Ascendente. Substituir, "de baixo para cima" a primeira variável de cada produção:

$L^{'} X Z B A L M \to MB b BZB ∣ a XBZB ∣ a BBZB ∣ b ZB ∣ b BB ∣ a XBB ∣ a BBB ∣ b B ∣ b ∣ A X a X ∣ A B a B ∣ λ \to L B b BZBB ∣ a XBZBB ∣ a BBZBB ∣ b ZBB ∣ b BBB ∣ a XBBB ∣ a BBBB ∣ b BB ∣ b B ∣ a XB ∣ a BB \to BBZ b BZ ∣ BB b B \to b \to a \to MB b BZB ∣ a XBZB ∣ a BBZB ∣ b ZB ∣ b BB ∣ a XBB ∣ a BBB ∣ b B ∣ b ∣ a X ∣ a B \to b BZ ∣ a XBZ ∣ a BBZ ∣ b Z ∣ b B ∣ a XB ∣ a BB ∣ b$

Sem anotações, a GIC final, $G^{6} = ({L^{'}, L, M, A, B, X, Z}, {a, b}, \dots, L^{'}) L^{'} X Z B A L M \to b BZB ∣ a XBZB ∣ a BBZB ∣ b ZB ∣ b BB ∣ a XBB ∣ a BBB ∣ b B ∣ b ∣ a X ∣ a B ∣ λ \to b BZBB ∣ a XBZBB ∣ a BBZBB ∣ b ZBB ∣ b BBB ∣ a XBBB ∣ a BBBB ∣ b BB ∣ b B ∣ a XB ∣ a BB \to b BZ ∣ b B \to b \to a \to b BZB ∣ a XBZB ∣ a BBZB ∣ b ZB ∣ b BB ∣ a XBB ∣ a BBB ∣ b B ∣ b ∣ a X ∣ a B \to b BZ ∣ a XBZ ∣ a BBZ ∣ b Z ∣ b B ∣ a XB ∣ a BB ∣ b$ está na Forma Normal de Greibach e é equivalente à GIC inicial $G^{0} = ({L, M, N, O}, {a, b, c, d}, \dots, L) L M N O \to M b ∣ a L b ∣ λ \to L b ∣ M L N ∣ λ \to N a N ∣ N b O \to c O ∣ λ$

Embora $G^{6}$ tenha muito mais produções do que $G^{0}$ e ainda por cima aparentemente redundantes (mas não o são) o facto de $G^{6}$ estar na FNG torna-a mais adequada e eficiente do que $G^{0}$ em termos de pesquisa. Por exemplo:

A derivação de uma palavra com $n$ símbolos tem, no máximo, $n$ passos porque cada produção "produz" um terminal.

O primeiro símbolo "filtra" as possíveis produções aplicáveis.

A pesquisa de uma palavra não gerada pela GIC, $p \neq \in L$ , "falha cedo", no máximo em $∣ p ∣$ passos.

Ver o exemplo no código deste capítulo.

Processo de Normalização de uma Gramática

Resumindo todos os passos, a normalização de uma GIC consiste em:

Eliminar a recursividade do símbolo inicial.
Eliminar as produções vazias exceto, se necessário, do símbolo inicial.
Eliminar as produções unitárias.
Eliminar os símbolos inúteis.
Transformar na Forma Normal de Chomsky.
Transformar na Forma Normal de Greibach.

Conclusão

O problema da Análise Sintática, que se está a tentar resolver, é uma reformulação do Problema Principal de ALP para as GIC e pergunta "como determinar se $p \in L$ " quando $p$ é uma palavra/programa e $L$ é uma linguagem gerada por uma gramática independente de contexto.

Inicialmente tentou-se formalizar as linguagens $L$ usando expressões regulares mas o Pumping Lemma mostrou a necessidade de uma abordagem mais geral — as gramáticas independentes de contexto.

Embora as GIC resolvam a adequação (com as expressões algébricas) e os autómatos de pilha proporcionem um modelo computacional, este não é eficiente.

A Normalização de uma GIC é um processo que começa com uma GIC e que, ao longo de vários passos, produz outras GIC equivalentes, de forma a obter-se uma gramática "adequada" aos algoritmos de pesquisa geral. A Forma Normal de Greibach impõe restrições fortes às produções, que podem ser bem aproveitadas para reduzir a complexidade/ramificação da pesquisa.

Mesmo com a FNG a ajudar na pesquisa, a resposta a " $p \in L$ " ainda permite ramificações ao pesquisar a árvore das derivações. Portanto o problema do não determinismo persiste e, com ele, a eficiência fica por resolver.

Os algoritmos deterministas são o próximo assunto e assentam, tanto quanto possível, nas propriedades das gramáticas e das derivações.

Gramáticas LL(k)

Análise Sintática Descendente Determinista.

Gramáticas LL(k)

Introdução

A Análise Sintática por pesquisa geral não é eficiente, mesmo após a transformação para a FNG porque continua a ser possível encontrarem-se várias produções para expandir um vértice.

Na situação acima o não determinismo resulta as possíveis múltiplas expansões quando se consideram as variáveis em isolamento. Por exemplo, dada a GIC abaixo, o vértice $a S$ tem dois filhos possíveis: $aa S$ e $a c A$ .

$S A B \to a S ∣ c A \to b A ∣ c B ∣ λ \to c B ∣ a ∣ λ$

Mas uma observação mais cuidadosa da pesquisa, considerando o primeiro símbolo do sufixo que falta derivar mostra uma situação interessante:

Pesquisa Descendente de $a cc$ com Avanço

Em cada vértice podam-se os ramos "incompatíveis".

Neste exemplo, olhando para o próximo terminal durante a pesquisa por $a cc$ obtém-se uma pesquisa determinista.

Nesta secção exploram-se pesquisas deterministas com o auxílio dos "símbolos seguintes".

Conteúdo

A apresentação intuitiva acima precisa de uma representação mais formal. Por exemplo, a derivação de $a c bb$ pode ser obtida pela seguinte tabela:

$prefixo λ a a c a c b a c bb avan \overset{c}{¸} o resto a c bb c bb b b b λ vari \overset{a}{ˊ} vel S S A A A produ \overset{c}{¸} \overset{a}{˜} o S \to a S S \to c A A \to b A A \to b A A \to λ deriva \overset{c}{¸} \overset{a}{˜} o S \Rightarrow a S \Rightarrow a c A \Rightarrow a c b A \Rightarrow a c bb A \Rightarrow a c bb$

Em cada linha:

Há uma variável ativa, que inicialmente é $S$ .
É escolhida a única produção cujo primeiro símbolo coincide com o símbolo de avanço.
O avanço é "transferido" para o prefixo processado e a variável ativa é a primeira que ocorre na produção escolhida na linha anterior.

Interessa formalizar esta exploração com vista a definir métodos rigorosos para:

Determinar se uma GIC é adequada, ou não, a este processo.

Definir algoritmos eficientes baseados na pesquisa com avanço.

Começando pela definição de gramática "adequada" à pesquisa com avanço:

Gramática LL(1). A GIC $G = (V, Σ, P, S)$ com terminador $#$ é LL(1) se dadas duas derivações esquerdas $S \Rightarrow * u_{1} A v_{1} \Rightarrow u_{1} x v_{1} \Rightarrow * u_{1} a w_{1} S \Rightarrow * u_{2} A v_{2} \Rightarrow u_{2} y v_{2} \Rightarrow * u_{2} a w_{2}$ em que $u_{i}, w_{i} \in Σ^{*}, a \in Σ$ e $A \in V$ então $x = y$ .

N.B. "LL" significa "Left-to-right Leftmost derivation". Em português: "derivação esquerda da esquerda-para-a-direita". Note-se que "derivação esquerda" especifica qual é a variável a tratar enquanto que "da esquerda-para-a-direita" indica que a palavra é processada sequencialmente do primeiro símbolo para o último.

N.B. O terminador ocorre exatamente uma vez nas palavras geradas e é sempre o último símbolo. A sua função é garantir que há sempre um símbolo de avanço na palavra analisada. Fica como exercício encontrar um algoritmo que transforma uma GIC qualquer, $A$ , noutra, $A^{'}$ com terminador $#$ , de forma que $p \in L (A) ⟺ p # \in L (A^{'})$ .

Intuitivamente a definição de GIC LL(1) diz que não há duas produções distintas de $A$ que produzem sufixos terminais que começam pelo mesmo terminal. Ou seja, os resultados finais da aplicação de duas produções de $A$ distintas difere logo no primeiro símbolo.

As gramáticas LL(1) têm algumas propriedades interessantes:

Propriedades das Gramáticas LL(1). Seja $G = (V, Σ, P, S)$ uma GIC:

Se $G$ é LL(1) então não é ambígua,

Se alguma variável de $G$ for recursiva à esquerda então $L$ não é LL(1).

A generalização de LL(1) para mais do que um símbolo de avanço é representada por $LL (k)$ . Este caso é pouco interessante em termos teóricos porque torna a notação mais críptica sem progredir na resolução da análise sintática.

Note-se que uma gramática na FNG quase que é LL(1). O problema está na possibilidade de várias produções começarem pelo mesmo terminal. Para ajudar a ultrapassar esta situação é preciso "arrumar" as produções que começam pelo mesmo símbolo.

Fatorização à Esquerda. Seja $G = (V, Σ, P, S)$ uma GIC. Supondo que as produções de $A \in V$ são $A \to p u_{1} ∣ p u_{2} ∣ \dots ∣ p u_{n} ∣ v_{1} ∣ v_{2} ∣ \dots ∣ v_{m}$

em que $p, u_{i}, v_{j} \in (V \cup Σ)^{*}$ então a GIC $G^{'}$ obtida de $G$

Acrescentando uma nova variável, $Z$ .

Substituindo as produções de $A$ por $A \to p Z ∣ v_{1} ∣ v_{2} ∣ \dots ∣ v_{m}$ .

Acrescentado as produções $Z \to u_{1} ∣ u_{2} ∣ \dots ∣ u_{n}$ .

é equivalente a $G$ .

Com a fatorização as várias produções de $A$ que começam pelo mesmo prefixo, $A \to p u_{1} ∣ p u_{2} ∣ \dots ∣ p u_{n}$ ficam agrupadas numa só produção, $A \to pZ$ e a nova variável, $Z$ , gera os restantes sufixos.

Por exemplo, recuperando a gramática $G^{6}$ que ilustrou da construção da FNG:

$Forma Normal de Greibach L^{'} \to b BZB ∣ a XBZB ∣ a BBZB ∣ b ZB ∣ b BB ∣ a XBB ∣ a BBB ∣ b B ∣ b ∣ a X ∣ a B ∣ λ ⋮ Fatorizada (duas aplica \overset{c}{¸} \overset{o}{˜} es) L^{'} Z_{1} Z_{2} \to b Z_{1} ∣ a Z_{2} ∣ λ \to BZB ∣ ZB ∣ BB ∣ B ∣ λ \to XBZB ∣ BBZB ∣ XBB ∣ BBB ∣ X ∣ B ⋮$

A fatorização pode ser aplicada repetidas vezes até que o resultado seja adequado, por exemplo uma GIC LL(1).

Para determinar se uma GIC é LL(1) a partir da definição pode ser confuso. Para ajudar neste problema mas também para definir um algoritmo determinista de análise sintática para gramáticas LL(1) usam-se os primeiros, seguintes e os diretores.

Primeiros. Seguintes. Seja $G = (V, Σ, P, S)$ uma GIC.

Os primeiros de $u \in (V \cup Σ)^{*}$ são os terminais que ocorrem na primeira posição das palavras derivadas de $u$ : $primeiros (u) = {a \in Σ : u \Rightarrow * a x \in Σ^{*}}$

Os seguintes de $A \in V$ são os terminais que ocorrem imediatamente a seguir a $A$ nalguma derivação de $G$ : $seguintes (A) = {a \in Σ : S \Rightarrow * u A v \land a \in primeiros (v)}$

Por exemplo, para a GIC $S A B \to a S ∣ c A \to b A ∣ c B ∣ λ \to c B ∣ a ∣ λ$

O conjunto dos ...	... é ...
primeiros de $a c$	${a}$
primeiros de $A$	${b, c}$
seguintes de $S$	$\emptyset$

A partir da definição não é simples calcular os conjuntos dos primeiros e dos seguintes. Para esse cálculo há dois algoritmos gráficos:

Grafo dos Primeiros. Seja $G = (V, Σ, P, S)$ uma GIC. O grafo dos primeiros é um grafo em que os vértices são os símbolos de $V \cup Σ$ e para cada produção $A \to s_{1} s_{2} \dots s_{n}$ :

Acrescenta-se a aresta $A ⟶ s_{1}$ .

Se $s_{1} \in Λ$ , acrescenta-se a aresta $A ⟶ s_{2}$ .

Assim sucessivamente até se esgotarem os $s_{i}$ ou $s_{i} \neq \in Λ$ .

O grafo dos primeiros tem um caminho $A ⟶ a \in Σ$ se e só se $a \in primeiros (A)$ .

Continuando com a GIC anterior, obtém-se

Exemplo de Grafo dos Primeiros

N.B. Os "cantos" das arestas são arredondados.

e, portanto, os primeiros de cada variável são:

$V S A B primeiros (V) {a, c} {b, c} {a, c}$

ou simplificando a notação: $S A B primeiros a c b c a c$

Este método mostra apenas os primeiros das variáveis. Para as restantes palavras:

Em geral, calculam-se recursivamente os $primeiros$ :

$primeiros (λ) = \emptyset$ .

Para $a \in Σ, primeiros (a) = {a}$ .

Para $A \in V$ usa-se o grafo dos primeiros.

Para $uv \in (V \cup Σ)^{*}$ :

${primeiros (u) \cup primeiros (v) primeiros (u) se u \Rightarrow * λ caso contr \overset{a}{ˊ} rio$

Depois dos primeiros (das variáveis) podem calcular-se os seguintes.

Grafo dos Seguintes. Seja $G = (V, Σ, P, S)$ uma GIC. O grafo dos seguintes é um grafo em que os vértices são os símbolos de $V \cup Σ$ e para cada produção $A \to u B v$ com $B \in V, u, v \in (V \cup Σ)^{*}$ :

Acrescenta-se uma aresta $B ⟶ a$ para cada $a \in primeiros (v)$ .

Se $v \Rightarrow * λ$ , acrescenta-se a aresta $B ⟶ A$ .

O grafo dos seguintes tem um caminho $A ⟶ a \in Σ$ se e só se $a \in seguintes (A)$ .

Continuando com o mesmo exemplo:

Exemplo de Grafo dos Seguintes

donde resulta $S A B seguintes \emptyset \emptyset \emptyset$

O próximo passo consiste em determinar os primeiros símbolos que cada produção gera.

Diretores. Seja $G = (V, Σ, P, S)$ uma GIC e $A \to p \in P$ . O conjunto dos diretores de $A \to p$ é: $diretores (A \to p) = {primeiros (p) \cup seguintes (A) primeiros (p) se p \Rightarrow * λ caso contr \overset{a}{ˊ} rio$

Depois de calculados os primeiros e os seguintes, os diretores são facilmente encontrados: $S \to a S S \to c A S \to λ A \to b A A \to c B A \to λ B \to c B B \to a B \to λ diretores a c \emptyset b c \emptyset c a \emptyset ✓ ✓ ✓$

Os diretores permitem facilmente verificar se uma GIC é LL(1):

Teorema dos Diretores. Seja $G = (V, Σ, P, S)$ uma GIC. Se, para qualquer variável $A \in V$ quaisquer duas produções de $A$ tiverem os respetivos diretores distintos, isto é, se $diretores (A \to u) \cap diretores (A \to v) = \emptyset$ para quaisquer duas produções de $A$ , então $G$ é LL(1)

Exemplos de Aplicação do Teorema dos Diretores

A GIC definida por $S \to a S a ∣ b S b ∣ λ$ não é LL(1):

$S primeiros ab seguintes ab$ e $S \to a S a S \to b S b S \to λ diretores a b ab nok$ Como $diretores (S \to λ) \cap diretores (S \to a S a) = {a, b} \cap {a} = {a} \neq = \emptyset$ conclui-se que esta gramática não é LL(1).

Um caso mais interessante é a seguinte variante das expressões algébricas, que ilustra a aplicação de algumas transformações:

$S E T S E Z T S E F Z W T S E Z X T \to E # \to E + T ∣ T \to (E) ∣ a \to E # \to TZ ∣ T \to + T Z ∣ + T \to (E) ∣ a \to E # \to TF \to Z ∣ λ \to + T W \to Z ∣ λ \to (E) ∣ a \to E # \to TX \to + TX \to Z ∣ λ \to (E) ∣ a recurs \overset{a}{˜} o direta \overset{a}{ˋ} esquerda prefixos comuns prefixos comuns repetida repetida$

Para verificar se esta última gramática é LL(1), passo a passo:

Geradores de Vazio

$Λ = {X} .$

Primeiros

Grafo dos Primeiros

Seguindo as arestas:

$S E Z X T primeiros (a (a + + (a$

Seguintes

Grafo dos Seguintes

Seguindo as arestas:

$S E Z X T seguintes #) #) #) #) +$

Diretores

$S E Z X X T T \to E # \to TX \to + TX \to Z \to λ \to (E) \to a diretores (a (a + + #) (a ✓ ✓$

Analisador Sintático

Com os diretores de cada produção calculados, se a gramática for LL(1), é simples implementar manualmente um Analisador Sintático para essa gramática:

def S():
    if seguinte in "(a":
        E()
        consome("#")
    else:
        erro()

def E():
    if seguinte in "(a":
        T()
        X()
    else:
        erro()

def Z():
    if seguinte in "+":
        consome("+")
        T()
        X()
    else:
        erro()

def X():
    if seguinte in "+":
        Z()
    elif seguinte in "#)":
        return
    else:
        erro()

def T():
    if seguinte in "(":
        consome("(")
        E()
        consome("(")
    elif seguinte in "a":
        consome("a")
    else:
        return erro()

def consome(terminal):
    if terminal == seguinte:
        # AVANÇA
        seguinte = ...
    else:
        erro()

def erro():
    # Para o processamento
    ...

Um exemplo deste programa a correr, para analisar a palavra a+a#, é:

"pilha"	`seguinte`	resto
`S()`	`a`	`+a#`
`E(); consome(#)`	`a`	`+a#`
`T(); X(); consome(#)`	`a`	`+a#`
`consome(a); X(); consome(#)`	`a`	`+a#`
`X(); consome(#)`	`+`	`a#`
`Z(); consome(#)`	`+`	`a#`
`consome(+); T(); X(); consome(#)`	`+`	`a#`
`T(); X(); consome(#)`	`a`	`#`
`consome(a); X(); consome(#)`	`a`	`#`
`X(); consome(#)`	`#`	(vazio)
`consome(#)`	`#`	(vazio)
(vazio)	(nenhum)	(vazio)

O resultado deste analisador sintático é "verdade" ou "falso" conforme a palavra dada é, ou não, gerada pela gramática. Este é o resultado esperado mas insatisfatório pois nada diz sobre a derivação, isto é a estrutura, da palavra.

Por exemplo, dada a palavra a+a# é desejável saber, além de que $G \Rightarrow * a + a #$ , que a sua derivação esquerda é $S \Rightarrow S \to E # E # \Rightarrow E \to E + T E + T # \Rightarrow E \to T T + T # \Rightarrow T \to a a + T # \Rightarrow T \to a a + a #$ na gramática inicial.

Conclusão

Este último exemplo mostra que a Análise Sintática está quase resolvida:

As GIC LL(1) são adequadas para representar as linguagens de programação. Além disso, é possível definir algoritmos eficientes para determinar computacionalmente se uma palavra é, ou não, gerada por essa gramática.

No entanto... ainda há por onde melhorar esta situação:

A transformação de uma GIC noutra que seja LL(1) é um passo Ad hoc, que depende de muitas escolhas específicas.
Nessa transformação perde-se a ligação à gramática inicial. Em concreto, olhando para a computação de a+a# não se percebe como a palavra é gerada pelas produções da gramática inicial.
Este processo implica a implementação "manual" das "produções" (human in the middle) mas seria muito melhor que fosse totalmente automático. Isto é, pretende-se definir um programa "geral" Super que aceita como entrada uma gramática G e devolve um certo programa P que, por sua vez, aceita como entrada uma palavra p e calcula se esta é, ou não, gerada por G:
1. P = Super(G).
2. P(p) é equivalente a "p é gerada por G".

Gramáticas LR(k)

Análise Sintática Ascendente Determinista.

Introdução

As gramáticas LL(1) resolvem o problema da Análise Sintática no sentido em que proporcionam:

Uma representação adequada para definir linguagens de programação.
Um método computacional e eficiente para determinar se uma palavra é gerada por uma gramática.

No entanto a construção do analisador sintático LL(1) a partir de uma GIC arbitrária implica alguns passos manuais (human in the middle) que devem ser evitados.

O objetivo para esta secção é resolver esses problemas:

Obter um programa que tem como entrada uma GIC e que produz um segundo programa que tem como entrada uma palavra e que determina se essa palavra pertence, ou não, à linguagem dada ao primeiro programa. Isto é, definir um programa Super tal que:

Se G for uma GIC, P = Super(G).

Seja p uma palavra. P(p) é "verdade" ou "falso" conforme G gera, ou não, p.

Tanto Super e P são eficientes.

Conteúdo

Para atingir esse objetivo:

São definidas as gramáticas LR(k), Left-to-right Rightmost derivation in reverse, em português "derivação direita da esquerda-para-a-direita em reverso", onde "em reverso" significa que os passos da derivação são descobertos do último para o primeiro, isto é, como numa pesquisa ascendente.
Dada uma gramática LR(n) é construído um analisador sintático como autómato de pilha determinista.

Estes analisadores sintáticos são eficientes no sentido em que detetam erros sintáticos assim que possível (isto é, quando a gramática não gera a palavra) mas (como se vai ver) o processo para os construir é muito trabalhoso quando feito à mão.

O "k" em LR(k) refere-se ao número de símbolos de avanço necessários para escolher deterministicamente as operações do AP. Para as gramáticas LR(0) não é preciso qualquer avanço, para as LR(1) é necessário um símbolo de avanço, etc.

Gramáticas LR(0)

Tal como antes para as gramáticas LL, o interesse aqui está nas gramáticas LR(1) porém o caso LR(0) é importante como introdução para o processo de construção do analisador sintático.

Gramáticas LR(0)

Contextos LR(0)

Problema. Quando é que uma produção pode ser aplicada numa derivação "válida"?

Isto é, será possível determinar quando a aplicação de uma produção numa derivação contribui para uma palavra gerada pela gramática das outras aplicações, em que o resultado não é gerado pela gramática?

No caso das derivações direitas

Contexto-LR(0). Prefixo Viável. Seja $G = (V, Σ, P, S)$ uma GIC com terminador $#$ e em que $S$ não é recursivo.

A palavra $u p \in (V \cup Σ)^{*}$ é um Contexto-LR(0) da produção $A \to p$ se existir uma derivação direita $S \Rightarrow_{R} * u A v \Rightarrow_{R} u p v, v \in Σ^{*} .$

Isto é, há uma redução $u p v \Leftarrow *_{R} S$ que começa por $A \to p$ .

Um prefixo viável é um prefixo de um contexto-LR(0).

Dada uma produção, o conjunto dos seus contextos-LR(0) é uma linguagem regular.

N.B. Na definição acima é importante ter presente que se tratam de derivações direitas. Portanto, quando $A \to p$ é aplicada em $u A v$ :

O sufixo $v$ é formado só por terminais.
O prefixo $u$ é o "contexto" para a aplicação da regra $A \to p$ .

Intuitivamente pretende-se que os Contextos-LR(0) tenham informação suficiente para determinar que produção aplicar em cada passo de uma derivação. Isto é, se os Contextos-LR(0) forem disjuntos tem-se um método determinista para fazer derivações direitas.

Por exemplo, dada a GIC $S A B \to a A ∣ a B \to a A b ∣ b \to b B a ∣ b$

As derivações direitas têm uma das seguintes formas

$S S \Rightarrow_{R} S \to a A \Rightarrow_{R} S \to a B a A a B \Rightarrow_{R} A \to a A b \Rightarrow_{R} B \to a B a \dots \dots \Rightarrow_{R} A \to a A b \Rightarrow_{R} B \to b B a a a^{n} A b^{n} a b^{n} B a^{n} \Rightarrow_{R} A \to b \Rightarrow_{R} B \to b a a^{n} b b^{n} a b^{n} b a^{n}$

pelo que os Contextos-LR(0) das produções são:

$produ \overset{c}{¸} \overset{a}{˜} o S \to a A S \to a B A \to a A b A \to b B \to b B a B \to b Contexto-LR(0) {a A} {a B} {a^{n} a A b : n > 0} {a a^{n} b : n \geq 0} {a b^{n} b B a : n \geq 0} {a b^{n} b : n \geq 0}$

Neste caso, $ab$ é um contexto-LR(0) tanto de $A \to b$ como de $B \to b$ (com $n = 0$ em ambos os casos).

O que é que isto significa? Quando se procura descobrir como $ab$ poderá ter sido derivada à esquerda, há duas possibilidades:

Ou $S \Rightarrow_{R} S \to a A a A \Rightarrow_{R} A \to b ab$ .
Ou $S \Rightarrow_{R} S \to a B a B \Rightarrow_{R} B \to b ab$ .

Isto é, em $ab$ não "há informação suficiente" para saber qual foi a última produção aplicada, $A \to b$ ou $B \to b$ .

Considerando agora a GIC

$S X Y \to X # \to X Y ∣ λ \to aYa ∣ b$

os contextos-LR(0) são:

$S \to X # X \to X Y X \to λ Y \to aYa Y \to b X # X Y λ X a^{*} aYa X a^{*} b$

Os contextos-LR(0) podem ser descobertos explorando a árvore das derivações direitas:

Árvore das Derivações Direitas

Os contextos-LR(0) estão sublinhados.

Agora, para encontrar uma derivação de $aabaa #$ :

O maior prefixo de $aabaa #$ que é um contexto-LR(0) é $λ$ , de $X \to λ$ .
Portanto, a produção aplicada foi $X \to λ$ , à palavra $X aabaa #$ .
O maior prefixo de $X aabaa #$ que é um contexto-LR(0) é $X aab$ , de $Y \to b$ .
Portanto, foi aplicada $Y \to b$ a $X aaYaa #$ .
O maior prefixo de $X aaYaa #$ que é um contexto-LR(0) é $X aaYa$ , de $Y \to aYa$ .
Portanto, foi aplicada $Y \to aYa$ a $X aYa #$ .
O maior prefixo de $X aYa #$ que é um contexto-LR(0) é $X aYa$ , de $Y \to aYa$ .
Portanto, foi aplicada $Y \to aYa$ a $X Y #$ .
O maior prefixo de $X Y #$ que é um contexto-LR(0) é $X Y$ , de $X \to X Y$ .
Portanto, foi aplicada $X \to X Y$ a $X #$ .
O maior prefixo de $X #$ que é um contexto-LR(0) é $X #$ , de $S \to X #$ .
Portanto, foi aplicada $S \to X #$ e a derivação está encontrada:

$S \Rightarrow_{R} S \to X # X # \Rightarrow_{R} X \to X Y X Y # \Rightarrow_{R} Y \to aYa X aYa # \Rightarrow_{R} Y \to aYa X aaYaa # \Rightarrow_{R} Y \to b X aabaa # \Rightarrow_{R} X \to λ aabaa #$

Note-se que:

Foi encontrada uma derivação direita (rightmost derivation).
A "pilha" é lida da esquerda-para-a-direita (left-to-right).
O processo encontra a derivação em reverso (in reverse).

A derivação anterior pode ser organizada numa tabela com quatro tipos de ações:

Reduzir $A \to w$ quando a pilha tem um Contexto-LR(0) de $A \to w$ .
Transferir o primeiro símbolo da palavra para a pilha, quando a pilha tem um prefixo viável que não é um Contexto-LR(0).
Aceitar quando a pilha é $S$ e a palavra $λ$ .
Rejeitar quando a pilha não é um prefixo viável.

O resultado é: $pilha λ X X a X aa X aab X aaY X aaYa X aY X aYa X Y X X # S palavra aabaa # aabaa # abaa # baa # aa # aa # a # a # # # # λ λ Contexto X \to λ vi \overset{a}{ˊ} vel vi \overset{a}{ˊ} vel vi \overset{a}{ˊ} vel Y \to b vi \overset{a}{ˊ} vel Y \to aYa vi \overset{a}{ˊ} vel T \to aYa X \to X Y vi \overset{a}{ˊ} vel S \to X # a \overset{c}{¸} \overset{a}{˜} o R T T T R T R T R R T R aceitar$

A derivação de $aabaa #$ pode ser recuperada da coluna "ação", lida em reverso.

Para procurar uma derivação de $abb #$ , que não é gerada pela gramática: $pilha λ X X a X ab X aY X aYb palavra abb # abb # bb # b # b # # Contexto X \to λ vi \overset{a}{ˊ} vel vi \overset{a}{ˊ} vel Y \to b vi \overset{a}{ˊ} vel invi \overset{a}{ˊ} vel a \overset{c}{¸} \overset{a}{˜} o R T T R T rejeitar$

Itens LR(0)

Os exemplos acima ilustram a utilidade dos contextos-LR(0) para a análise sintática. Embora não sejam facilmente encontrados a partir da definição, o conjunto dos Contextos-LR(0) de uma produção é uma linguagem regular que pode ser definida por um certo autómato finito determinista.

Para definir esse AFD é preciso começar pelos seus estados:

Item LR(0). Seja $G = (V, Σ, P, V)$ uma GIC.

Os itens LR(0) de $G$ são as "produções" que se obtêm de $P$ acrescentado um $\cdot$ em todas as posições possíveis:

Se $A \to λ \in P$ então $A \to \cdot$ é um item LR(0) de $G$ .

Se $A \to uv \in P$ então $A \to u \cdot v$ é um item LR(0) de $G$ .

Um item completo é um item em que o $\cdot$ está o mais à direita possível.

Um item $A \to u \cdot v$ é válido para o prefixo viável $xu$ se $xuv$ é um contexto LR(0); Isto é, se $A \to uv$ é candidato a reduzir.

Usando a gramática do exemplo anterior, os seus itens LR(0) são $S X X Y Y \to \cdot X # \to \cdot X Y \to \cdot \to \cdot aYa \to \cdot b S X Y Y \to X \cdot # \to X \cdot Y \to a \cdot Ya \to b \cdot S X Y \to X # \cdot \to X Y \cdot \to aY \cdot a Y \to aYa \cdot$ com os itens completos assinalados assim: $A \to p \cdot$ .

Fecho. Seja $I$ um conjunto de itens. O fecho de $I$ , denotado $fecho (I)$ define-se recursivamente por:

base $I \subseteq fecho (I)$ .

passo Se $A \to u \cdot B v \in fecho (I)$ com $B \in V$ então, para cada produção $B \to p \in P$ , também $B \to \cdot p \in fecho (I)$ .

Por exemplo, usando a gramática anterior,

$fecho (X \to X \cdot Y) = {X \to X \cdot Y, Y \to \cdot aYa, Y \to \cdot b}$

Autómato Finito dos Itens LR(0) Válidos

Os fechos dos itens são usado para construir um autómato finito que determina a ação nas tabelas acima.

Autómato dos Itens Válidos (AIV). Seja $G = (V, Σ, P, S)$ uma GIC. O autómato dos itens válidos, que reconhece os prefixos viáveis de $G$ é o AFD $A = (Q, V \cup Σ, δ, q_{I}, Q ∖ {\emptyset})$ em que:

estado inicial $q_{I} = fecho ({S \to \cdot p : S \to p \in P})$ .

transição Para cada $q \in Q$ e $x \in V \cup Σ$

$δ (q, x) = fecho ({A \to u x \cdot v : A \to u \cdot x v \in q})$

Continuando com a gramática anterior, o seu autómato dos itens válidos tem os seguintes estados e transição:

$estado 01234567 \exists completo ? ✓ ✓ ✓ ✓ ✓ itens S \to \cdot X #, X \to \cdot X Y, X \to \cdot S \to X \cdot #, X \to X \cdot Y, Y \to \cdot aYa, Y \to \cdot b S \to X # \cdot X \to X Y \cdot Y \to a \cdot Ya, Y \to \cdot aYa, Y \to \cdot b Y \to b \cdot Y \to aY \cdot a Y \to aYa \cdot s \overset{ı}{ˊ} mbolo X # Y a b Y a b a para 123456457$

Note-se que há mais um estado, $\emptyset$ , que não se representa e que recebe todas as transições que não estão especificadas.

Este AFD pode ser representado numa tabela mais convencional (todas as transições não assinaladas vão para $\emptyset$ ):

$q i f 0 f 1 f 2 f 3 f 4 f 5 f 6 f 7 \emptyset S X 1 Y 36 a 447 b 55 # 2$

Porém, pode ser mais simples calcular graficamente os estados e a transição do autómato dos itens válidos.

Diagrama do Autómato dos Itens Válidos

Em cada estado os itens completos são assinalados com $⋆$ . O estado $\emptyset$ não está representado.

Neste diagrama cada estado tem dois ou três "andares". De cima para baixo:

O "nome" do estado, um inteiro $0, 1, \dots$
A "raiz" dos itens, que resultam da transição.
Restantes itens, para se obter o fecho da "raiz".

Analisador Sintático LR(0)

O Autómato dos itens válidos serve para determinar a ação na derivação. Em cada passo o AIV processa a pilha e a ação é:

Aceitar se a pilha tem apenas $S$ .
Reduzir se terminar num estado com um item completo. Nesse caso a redução é da produção do item completo.
Transferir o próximo símbolo da palavra se terminar num estado sem itens completos.
Rejeitar se não puder processar a palavra (isto é, vai parar a $\emptyset$ ).

Recuperando o exemplo anterior, o processamento de $aabaa #$ é:

$pilha λ X X a X aa X aab X aaY X aaYa X aY X aYa X Y X X # S palavra aabaa # aabaa # abaa # baa # aa # aa # a # a # # # # λ λ estado AIV 014456767312 a \overset{c}{¸} \overset{a}{˜} o R : X \to λ T T T R : Y \to b T R : Y \to aYa T R : T \to aYa R : X \to X Y T R : S \to X # aceitar$

enquanto que para $abb #$ , que não é gerada pela gramática: $pilha λ X X a X ab X aY X aYb palavra abb # abb # bb # b # b # # estado AIV 01456 \emptyset a \overset{c}{¸} \overset{a}{˜} o R : X \to λ T T R : Y \to b T rejeitar$

Tabela de Análise Sintática LR(0)

A tabela de análise sintática (TAS) estende a transição do AIV com as ações associadas aos respetivos estados. Tem uma linha para cada estado e uma coluna para cada símbolo de $V \cup Σ$ . Além disso tem também uma coluna, $a \overset{c}{¸} \overset{a}{˜} o$ , que indica que ação corresponde a um prefixo que termine nesse estado.

Para a gramática que tem vindo a servir de exemplo, a TAS é:

$q 01234567 S X 1 Y 36 a 447 b 55 # 2 a \overset{c}{¸} \overset{a}{˜} o R : X \to λ T A R : X \to X Y T R : Y \to b T R : Y \to aYa$

Nesta tabela:

O estado $\emptyset$ , a que corresponde a ação "rejeitar", não é representado e portanto todos os estados mostrados na TAS são finais.
As transições não representadas levam ao estado $\emptyset$ .
Por convenção, o estado $0$ é o inicial.
Nos estados com itens completos do símbolo inicial da GIC (no exemplo acima, o estado $2$ ) a ação é "aceitar", $A$ , em vez de ser "reduzir", $R$ .

Dado que a coluna $a \overset{c}{¸} \overset{a}{˜} o$ determina se no analisador sintático é feita uma transferência ou uma redução (e nesse caso, de que produção), se essa informação for ambígua não é possível fazer análise sintática determinista LR(0).

Portanto é necessário que cada estado defina exatamente uma ação.

Como as reduções são feitas em estados com itens completos (por exemplo, os estados $0, 2, 3, 5, 7$ acima) e as transferência são feitas em estados de que sai alguma "aresta com um terminal" (os estados $1, 4, 6$ acima), as ambiguidades (conflitos) possíveis são:

Conflito Redução/Redução LR(0): Se num estado estiverem dois itens completos então esse estado define duas reduções possíveis.
Conflito Redução/Transferência LR(0): Se num estado com um item completo sair uma aresta "com um terminal" então esse estado define uma redução e uma transferência.

Estas condições permitem caraterizar as gramáticas LR(0):

Teorema das Gramáticas LR(0). Uma GIC é LR(0) se e só se o seu AIV não tem conflitos redução/redução LR(0) nem redução/transferência LR(0).

Autómato de Pilha LR(0)

Pretende-se não só fazer análise sintática determinista mas também que esta seja livre de passos manuais (human in the middle). O AIV proporciona dois passos desse processo:

Determina se a GIC dada é LR(0).
Define a ação em cada passo do analisador sintático.

Falta definir formalmente o processamento do próprio analisador sintático, o que será feito com um autómato de pilha.

Autómato de Pilha Reconhecedor LR(0). Seja $G = (V, Σ, P, S)$ uma GIC LR(0) e $A = (Q, V \cup Σ, δ_{A}, 0, Q ∖ {\emptyset})$ o seu AIV. O Autómato de Pilha Reconhecedor (APR) de $G$ , que reconhece a linguagem gerada por $G$ , é $R = ({p_{I}, p}, Σ, V \cup Σ \cup Q ∖ {\emptyset}, δ, p_{I}, {p})$ em que a transição, $δ$ , é definida pelos seguintes elementos:

iniciar: $(p, 0) \in δ (p_{I}, λ, λ)$ .

transferir: $(p, q^{'} a q) \in δ (p, a, q)$ se $q^{'} = δ_{A} (q, a)$ com $a \in Σ$ .

reduzir: Para cada estado $q_{n} \in Q$ com um item completo $A \to a_{1} a_{2} \dots a_{n} \cdot$ com $A \neq = S$ e $q^{'} = δ_{A} (q_{0}, A)$ , $(p, q^{'} A q_{0}) \in δ (p, λ, q_{n} a_{n} \dots q_{2} a_{2} q_{1} a_{1} q_{0})$ quando no AIV existe a computação $q_{0} ⊢ a_{1} q_{1} ⊢ a_{2} q_{2} \dots ⊢ a_{n} q_{n} .$

aceitar: Para cada estado $q_{n} \in Q$ com um item completo $S \to a_{1} a_{2} \dots a_{n} \cdot$ do símbolo inicial da GIC, $(p, λ) \in δ (p, λ, q_{n} a_{n} \dots q_{2} a_{2} q_{1} a_{1} 0)$ quando no AIV existe a computação $0 ⊢ a_{1} q_{1} ⊢ a_{2} \dots ⊢ a_{n} q_{n} .$

Intuitivamente a pilha do APR intercala estados do AIC com símbolos de $V \cup Σ$ de forma a descrever "fragmentos de computação do AIV". Por exemplo, a computação de $abb #$ $pilha λ X X a X ab X aY X aYb palavra abb # abb # bb # b # b # # estado AIV 01456 \emptyset a \overset{c}{¸} \overset{a}{˜} o R : X \to λ T T R : Y \to b T rejeitar pilha APR 0 1 X 0 4 a 1 X 0 5 b 4 a 1 X 0 6 Y 4 a 1 X 0 \emptyset b 6 Y 4 a 1 X 0 topo: de 014 5 b 4 6 topo: para 1 X 0 4 a 1 5 b 4 6 Y 4 \emptyset b 6$ enquanto que de $aabaa #$ é: $pilha λ X X a X aa X aab X aaY X aaYa X aY X aYa X Y X X # S palavra aabaa # aabaa # abaa # baa # aa # aa # a # a # # # # λ λ estado AIV 014456767312 a \overset{c}{¸} \overset{a}{˜} o R : X \to λ T T T R : Y \to b T R : Y \to aYa T R : T \to aYa R : X \to X Y T R : S \to X # aceitar pilha APR 0 1 X 0 4 a 1 X 0 4 a 4 a 1 X 0 5 b 4 a 4 a 1 X 0 6 Y 4 a 4 a 1 X 0 7 a 6 Y 4 a 4 a 1 X 0 6 Y 4 a 1 X 0 7 a 6 Y 4 a 1 X 0 3 Y 1 X 0 1 X 0 2 # 1 X 0 λ$

Estes exemplos ilustram como o topo da pilha determina a transição do APR: O primeiro símbolo identifica o estado do AIV e este define ou uma transferência ou uma redução (incluindo o caso particular da aceitação).

No caso de reduzir (ou aceitar) são considerados mais símbolos da pilha, de forma a "capturar" todo o lado direito da produção, que é substituído pela respetiva variável.

No caso da operação ser uma transferência o terminal da palavra é comparado com a parte correspondente na pilha e, se coincidirem, ambos são "consumidos".

Neste processo é mantido o registo dos estados do AIV percorridos pelas respetivas computações.

Alternativamente as transições do APR podem ser definidas pela seguinte tabela:

$Opera \overset{c}{¸} \overset{a}{˜} o Iniciar Transferir Reduzir Aceitar Condi \overset{c}{¸} \overset{a}{˜} o q^{'} = δ_{A} (q, a) A \to a_{1} \dots a_{n} \cdot ⋆ \in q A \neq = S q_{0} ⊢ a_{1} \dots ⊢ a_{n} q_{n}, q_{n} = q α = q_{n} a_{n} \dots a_{1} q_{0} q_{0} ⊢ A q^{'} β = q^{'} A q_{0} S \to a_{1} \dots a_{n} \cdot ⋆ \in q 0 ⊢ a_{1} \dots ⊢ a_{n} q_{n}, q_{n} = q α = q_{n} a_{n} \dots a_{1} 0 De p_{I} p p p Aresta λ, λ / 0 a, q / q^{'} a q λ, α / β λ, α / λ Para p p p p$

Por exemplo para a GIC anterior, com a TAS (calculada acima, repetida aqui)

$q 01234567 S X 1 Y 36 a 447 b 55 # 2 a \overset{c}{¸} \overset{a}{˜} o R : X \to λ T A R : X \to X Y T R : Y \to b T R : Y \to aYa$ as transições do APR são:

iniciar $λ, λ / 0$ é a única transição $p_{I} \to p$ .
transferir Estas transições são $p ⊢ p$ :

$AIV: Computa \overset{c}{¸} \overset{a}{˜} o 1 ⊢ a 4 1 ⊢ b 5 1 ⊢ # 2 4 ⊢ a 4 4 ⊢ b 5 6 ⊢ a 7 APR: Transi \overset{c}{¸} \overset{a}{˜} o a, 1 / 4 a 1 b, 1 / 5 b 1 #, 1 / 2 # 1 a, 4 / 4 a 4 b, 4 / 5 b 4 a, 6 / 7 a 6$
reduzir Estas transições são $p ⊢ p$ :

$AIV: Estado 0357 AIV: Item completo de A \neq = S X \to λ \cdot X \to X Y \cdot Y \to b \cdot Y \to aYa \cdot AIV: Computa \overset{c}{¸} \overset{a}{˜} o 0 0 ⊢ X 1 ⊢ Y 3 1 ⊢ b 5 4 ⊢ b 5 1 ⊢ a 4 ⊢ Y 6 ⊢ a 7 4 ⊢ a 4 ⊢ Y 6 ⊢ a 7 APR: Transi \overset{c}{¸} \overset{a}{˜} o λ, 0 / 1 X 0 λ, 3 Y 1 X 0 / 1 X 0 λ, 5 b 1 / 3 Y 1 λ, 5 b 4 / 6 Y 4 λ, 7 a 6 Y 4 a 1 / 3 Y 1 λ, 7 a 6 Y 4 a 4 / 6 Y 4$
aceitar Estas transições são $p ⊢ p$ :

$AIV: Estado 2 AIV: Item completo de S S \to X # \cdot AIV: Computa \overset{c}{¸} \overset{a}{˜} o 0 ⊢ X 1 ⊢ # 2 APR: Transi \overset{c}{¸} \overset{a}{˜} o λ, 2 # 1 X 0 / λ$

O diagrama do APR é:

Diagrama do APR

As transições para transferir estão no ciclo superior, aceitar no direito e reduzir no inferior.

O APR replica os passos (informais) do analisador sintático. A computação de $abb #$ pelo APR é:

$Estado p_{I} p p p p p Pilha λ 0 1 X 0 4 a 1 X 0 5 b 4 a 1 X 0 6 Y 4 a 1 X 0 Entrada abb # abb # abb # bb # b # b # Transi \overset{c}{¸} \overset{a}{˜} o λ, λ / 0 λ, 0 / 1 X 0 a, 1 / 4 a 1 b, 4 / 5 b 4 λ, 5 b 4 / 6 Y 4 \emptyset A \overset{c}{¸} \overset{a}{˜} o iniciar (p_{I} ⊢ p) reduzir X \to λ transferir transferir reduzir Y \to b rejeitar$ e pára porque atinge uma configuração sem transições definidas (o topo é $6$ e o símbolo da entrada é $b$ ). Por outro lado a computação de $aabaa #$ é: $Estado p_{I} p p p p p p p p p p p p p Pilha λ 0 1 X 0 4 a 1 X 0 4 a 4 a 1 X 0 5 b 4 a 4 a 1 X 0 6 Y 4 a 4 a 1 X 0 7 a 6 Y 4 a 4 a 1 X 0 6 Y 4 a 1 X 0 7 a 6 Y 4 a 1 X 0 3 Y 1 X 0 1 X 0 2 # 1 X 0 λ Entrada aabaa # aabaa # aabaa # abaa # baa # aa # aa # a # a # # # # λ λ Transi \overset{c}{¸} \overset{a}{˜} o λ, λ / 0 λ, 0 / 1 X 0 a, 1 / 4 a 1 a, 4 / 4 a 4 b, 4 / 5 b 4 λ, 5 b 4 / 6 Y 4 a, 6 / 7 a 6 λ, 7 a 6 Y 4 a 4 / 6 Y 4 a, 6 / 7 a 6 λ, 7 a 6 Y 4 a 1 / 3 Y 1 λ, 3 Y 1 X 0 / 1 X 0 #, 1 / 2 # 1 λ, 2 # 1 X 0 / λ A \overset{c}{¸} \overset{a}{˜} o iniciar (p_{I} ⊢ p) reduzir X \to λ transferir transferir transferir reduzir Y \to b transferir reduzir Y \to aYa transferir reduzir Y \to aYa reduzir X \to X Y transferir aceitar S \to X #$ e termina numa configuração com um estado final e com a pilha e a entrada ambas vazias. Neste caso, lendo em reverso as produções obtém-se a derivação direita da palavra dada: $S \Rightarrow_{R} S \to X # X # \Rightarrow_{R} X \to X Y X Y # \Rightarrow_{R} Y \to aYa X aYa # \Rightarrow_{R} Y \to aYa X aaYaa # \Rightarrow_{R} Y \to b X aabaa # \Rightarrow_{R} X \to λ aabaa #$

Este exemplo ilustra o tratamento "automático" da análise sintática das gramáticas LR(k).

Dada uma GIC, a construção do AIV e a respetiva TAS permite determinar se a GIC é, ou não LR(0).

Se o for, a TAS é usada para construir o APR que reconhece a linguagem gerada pela GIC.

Além disso, o processamento de uma palavra aceite pelo APR permite encontrar a derivação direita dessa palavra.

Em todo este processo, desde a construção do AIV e da TAS, do APR e a computação de palavras os algoritmos são eficientes (isto é, o número de passos é polinomial no tamanho do input.)

Resta saber se as gramáticas LR(0) são adequadas.

Considerando a seguinte gramática de expressões algébricas simplificadas:

$S E T F \to E # \to E + T ∣ T \to T \times F ∣ F \to n ∣ (E)$

Na construção do AIV desta GIC o estado inicial tem os seguintes itens:

$S E E T ⋮ 0 \to \cdot E # \to \cdot E + T \to \cdot T \to \cdot T \times F$

Deste estado sai uma aresta $T$ que leva a um novo estado com os seguintes itens $E T ⋮ ? \to T \cdot \to T \cdot \times F ⋆$ onde existe um conflito redução/transferência (a redução de $E \to T$ com a transferência de $\times$ ).

Este exemplo mostra que as gramáticas LR(0) são demasiado simples para definir expressões algébricas e portanto não são adequadas para definir as linguagens de programação.

A solução para este problema consiste em "adaptar" a ideia das gramática LL(1), considerando os símbolos de avanço, ao processo das gramáticas LR(0).

Conclusão

O que conseguimos resolver
O que falta resolver.

Gramáticas LR(1)

Gerador de Analisador Sintático a partir da GIC.

Gramáticas LR(1)

Embora as gramáticas LR(0) proporcionem um algoritmo completo e eficiente para a análise sintática, as linguagens abrangidas não incluem expressões algébricas, pelo que é necessário considerar um esquema mais adequado.

Aqui que entram as gramáticas LR(1), que usam informação sobre o "proximo terminal não processado" (o avanço) para guiar o processo da análise sintática.

Item LR(1)

Seguindo a estrutura da apresentação das gramáticas LR(0), define-se:

Itens, Itens Válidos e Fecho de um conjunto de itens.
Autómato dos itens válidos.
Condições LR(1).
Tabela de Análise Sintática.
Autómato de Pilha Reconhecedor.

Item LR(1). Item LR(1) Válido. Seja $G = (V, Σ, P, S)$ uma GIC.

Um Item LR(1) de $G$ tem a forma $(A \to u \cdot v, L)$ onde:

núcleo $A \to u \cdot v$ é um item LR(0).

símbolos de avanço $L \subseteq Σ \cup {#}$ .

O item LR(1) $(A \to u \cdot v, L)$ é válido para $xu$ se, para cada $a \in L$ existe uma derivação $S \Rightarrow_{R} * x A y$ com $a \in primeiros (y #)$ .

O fecho de um conjunto de itens afeta os símbolos de avanço.

O Fecho LR(1) de um conjunto $X$ de itens LR(1) define-se recursivamente:

base $X \subseteq fecho_{1} (X)$ .

passo Se $(A \to u \cdot B v, L) \in fecho_{1} (X), B \in V$ então, para cada produção $B \to w$ também $(B \to \cdot w, K) \in fecho_{1} (X)$ onde $K = {primeiros (v) \cup L primeiros (v) v \Rightarrow * λ caso contr \overset{a}{ˊ} rio$

fecho nada mais pertence a $fecho_{1} (X)$ .

Por exemplo, dada a GIC $S A \to A b A \to A a ∣ λ$ tem-se $fecho_{1} (S \to A b \cdot A, {#}) = {(S \to A b \cdot A, {#})} \cup {(A \to \cdot A a, {#}), (A \to \cdot, {#})} \cup {(A \to \cdot A a, {a}), (A \to \cdot, {a})} = ⎩ ⎨ ⎧ S \to A b \cdot A, # A \to \cdot A a, # A \to \cdot, # A \to \cdot A a, a A \to \cdot, a ⎭ ⎬ ⎫$

Autómato Finito dos Itens LR(1) Válidos

Tal como nas gramáticas LR(0), os itens LR(1) válidos são reconhecidos por um AFD.

Autómato dos Itens LR(1) Válidos (AIV). Seja $G = (V, Σ, P, S)$ uma GIC qualquer e $G^{'} = (V \cup {S^{'}}, Σ, P \cup {S^{'} \to S}, S^{'}) .$

O autómato dos itens LR(1) válidos de $G^{'}$ é o AFD $A = (Q, V \cup Σ, δ, 0, Q ∖ {\emptyset})$ tal que:

estado inicial $0 = fecho_{1} (S^{'} \to S, #)$ .

transição Para cada $q \in Q, x \in V \cup Σ$ ,

$δ (q, x) = fecho_{1} ({(A \to u x \cdot v, L) : (A \to u \cdot x v, L) \in q}) .$

Por exemplo, para a GIC dada acima:

Diagrama do Autómato dos Itens LR(1) Válidos

Em cada estado os itens completos são assinalados com $⋆$ . O estado $\emptyset$ não está representado.

O cálculo de $fecho_{1} (S^{'} \to \cdot S, #)$ passo-a-passo:

Como ocorre $\cdot S$ , é necessário adicionar os itens iniciais de $S$ . O núcleo é $S \to \cdot A b A$ .
Para calcular o avanço deste item, note-se que inicialmente $(S^{'} \to \cdot S λ v, # L)$ portanto, pela definição de $fecho_{1}$ , $K = primeiros (λ) \cup L = \emptyset \cup {#} = {#}$ .
Portanto, o item LR(1) a acrescentar em $0$ é $S \to \cdot A b A, #$ .
Agora, de $S \to \cdot A b A, #$ é preciso acrescentar os itens iniciais de $A$ . Os núcleos são $A \to \cdot A a$ e $A \to \cdot$ . O cálculo dos avanços é idêntico para estes dois itens.
Estes itens resultam de $S \to \cdot A b v A, #$ . Pela definição de $fecho_{1}$ , $K = primeiros (b) = {b}$ .
Portanto, são acrescentados dois itens LR(1): $A \to \cdot A a, b$ e $A \to \cdot, b$ .
Do item $A \to \cdot A a v, b$ , pelas razões anteriores, é necessário acrescentar dois itens LR(1): $A \to \cdot A a, a$ e $A \to \cdot, a$ .
Torna a acontecer $A \to \cdot A a v, a$ mas os itens que resultam já constam no $fecho_{1}$ e nada mais é acrescentado.
Finalmente o fecho tem vários itens com o mesmo núcleo e que diferem apenas no avanço. Neste caso esses itens "fundem-se" num único, unindo os avanços:
1. $A \to \cdot A a, b$ e $A \to \cdot A a, a$ fundem-se em $A \to \cdot A a, ab$ .
2. $A \to \cdot, b$ e $A \to \cdot, a$ fundem-se em $A \to \cdot, ab$ .

Tabela de Análise Sintática LR(1)

Tal como no caso das gramáticas LR(0), os estados do AIV LR(1) permitem determinar se o processo da análise sintática pode, ou não, ser aplicado.

Para que a análise sintática seja determinista é necessário que os estados sejam livres de conflitos (redução/redução e redução/transferência). No caso das gramáticas LR(0), sem informação sobre os avanços, cada estado do AIV pode determinar ou uma única redução ou uma transferência. Nos AIV das gramáticas LR(1) os itens têm avanços, que proporcionam decisões mais informadas em cada caso.

No AIV acima, visto como um AIV LR(0), o estado $5$ tem um conflito redução/transferência. Mas o avanço do item $S \to A b A, #$ restringe a aplicação da redução apenas quando o avanço na entrada é $#$ . Portanto não há conflito com uma eventual transferência de $a$ .

Em cada estado, cada avanço identifica a ação (reduzir, transferir, aceitar, rejeitar) no processo da análise sintática.

Portanto, a tabela de análise sintática LR(1) tem uma ação possível para cada símbolo terminal. Especificamente:

Tabela de Análise Sintática LR(1). (TAS LR(1)) Dada uma GIG e o seu AIV LR(1), a tabela de análise sintática LR(1) tem:

Para cada estado do AIV LR(1), uma linha, exceto para o estado $\emptyset$ .

Para cada símbolo $(V \cup Σ) ∖ {S^{'}}$ , uma coluna que descreve a transição do AIV.

Para cada símbolo $a \in Σ \cup {#}$ , uma coluna que, cruzada com a linha do estado $q$ , determina a ação:

aceitar (ou $A$ ) se $q$ contém um item completo de $S^{'}$ e se $a = #$ .

transferir (ou $T$ ) se $q$ contém um item $A \to u \cdot a v, L$ .

reduzir (ou $R : A \to p$ ) se $q$ contém o item completo $A \to p \cdot, L$ , $A \neq = S$ e $a \in L$ .

rejeitar (omitido).

Por exemplo, A TAS LR(1) do exemplo acima é:

$q 0123456 S 1 A 25 a 36 b 4 a A \to λ transferir A \to A a A \to λ transferir A \to A a b A \to λ transferir A \to A a # aceitar A \to λ S \to A b A A \to A a$

Comparando esta tabela com as obtidas nas TAS LR(0), a coluna ação é mais específica, considerando agora os símbolos de avanço e, portanto, a ação depende não só do estado no AIV mas também do próximo símbolo na entrada.

Numa TAS LR(1) mantém-se a necessidade de determinar, sem ambiguidade, cada ação no processo da análise sintática. Em relação ao caso LR(0), a escolha da ação depende não só do estado do AIV mas também do símbolo de avanço.

Quando esta informação (estado AIV + símbolo de avanço) não é suficiente para determinar uma única ação tem-se um conflito, que pode ser de dois tipos:

Conflito Redução/Redução LR(1): Num estado com dois itens completos em que os avanços se intersetam. Formalmente, se no AIV LR(1) existe um estado com dois itens completos distintos $(A \to p \cdot, L)$ e $(B \to q \cdot, K)$ e $L \cap K \neq = \emptyset$ .
Conflito Redução/Transferência LR(1): Num estado com um item completo em que sai uma aresta "com um terminal" que está no avanço desse item completo. Formalmente, se no AIV LR(1) existe um item completo $(A \to p \cdot, L)$ e um item $(B \to u \cdot a v, L)$ e $a \in L$ .

Teorema das Gramáticas LR(1). Uma GIC é LR(1) se e só se o seu AIV não tem conflitos redução/redução LR(1) nem redução/transferência LR(1).

Autómato de Pilha Reconhecedor LR(1)

Quando o AIV LR(1) de uma GIC está livre de conflitos é possível definir-se um autómato de pilha para reconhecer a linguagem gerada pela GIC. Além disso, para as palavras geradas/aceites, a observação da computação permite recuperar a derivação direita da respetiva palavra.

Autómato de Pilha Reconhecedor LR(1). Seja $G = (V, Σ, P, S)$ uma GIC LR(1) e $A = (Q, V \cup Σ, δ_{A}, 0, Q ∖ {\emptyset})$ o seu AIV LR(1). O Autómato de Pilha Reconhecedor LR(1) (APR LR(1)) de $G$ , que reconhece a linguagem gerada por $G$ , é $R = (Q_{R}, Σ \cup {#}, V \cup Σ \cup Q ∖ {\emptyset}, δ, p_{I}, F_{R})$ com

estados de controlo: $Q_{R} = {p_{I}, p} \cup {p_{a} : a \in Σ \cup {#}}$ .

estados finais: $F_{R} = {p_{#}}$ .

e em que a transição, $δ$ , é definida pelos seguintes elementos:

iniciar: $(p, 0) \in δ (p_{I}, λ, λ)$ .

avançar: Para cada $a \in Σ \cup {#}$ então $(p_{a}, λ) \in δ (p, a, λ)$ .

transferir: Para cada $q \in Q$ com um item $(A \to u \cdot a v, L)$ em que $a \in Σ$ e $q^{'} = δ_{A} (q, a)$ então $(p, q^{'} a q) \in δ (p_{a}, λ, q)$ .

reduzir: Para cada estado $q \in Q$ com um item completo $(A \to a_{1} a_{2} \dots a_{n} \cdot, L)$ com $A \neq = S^{'}$ e para cada $a \in L$ , quando no AIV existe a computação $q_{0} ⊢ a_{1} q_{1} ⊢ a_{2} q_{2} \dots ⊢ a_{n} q_{n} = q$ e $q^{'} = δ_{A} (q_{0}, A)$ então $(p_{a}, q^{'} A q_{0}) \in δ (p_{a}, λ, q_{n} a_{n} \dots q_{2} a_{2} q_{1} a_{1} q_{0})$ .

aceitar: Para cada estado $q \in Q$ com um item completo $(S^{'} \to a_{1} a_{2} \dots a_{n} \cdot, L)$ do símbolo inicial da GIC, se $# \in L$ e quando no AIV existe a computação $0 ⊢ a_{1} q_{1} ⊢ a_{2} \dots ⊢ a_{n} q_{n} = q$ então $(p_{#}, λ) \in δ (p_{#}, λ, q_{n} a_{n} \dots q_{2} a_{2} q_{1} a_{1} 0) .$

Alternativamente as transições do APR LR(1) podem ser descritas pela seguinte tabela: $Opera \overset{c}{¸} \overset{a}{˜} o Iniciar Avan \overset{c}{¸} ar Transferir Reduzir Aceitar Condi \overset{c}{¸} \overset{a}{˜} o a \in Σ \cup {#} (A \to u \cdot a v, L) \in q a \in Σ q^{'} = δ_{A} (q, a) (A \to a_{1} \dots a_{n} \cdot, L) ⋆ \in q A \neq = S^{'} a \in L q_{0} ⊢ a_{1} \dots ⊢ a_{n} q_{n}, q_{n} = q α = q_{n} a_{n} \dots a_{1} q_{0} q_{0} ⊢ A q^{'} β = q^{'} A q_{0} (S^{'} \to a_{1} \dots a_{n} \cdot, L) ⋆ \in q # \in L 0 ⊢ a_{1} \dots ⊢ a_{n} q_{n}, q_{n} = q α = q_{n} a_{n} \dots a_{1} 0 De p_{I} p p_{a} p_{a} p_{#} Aresta λ, λ / 0 a, λ / λ λ, q / q^{'} a q λ, α / β λ, α / λ Para p p_{a} p p_{a} p_{#}$

Intuitivamente os estados do APR LR(1) refinam os do APR LR(0) com informação sobre o avanço. O estado $p$ "consulta" o símbolo de avanço (por exemplo, $a$ ) e encaminha a computação para o respetivo estado $p_{a}$ , onde os passos são feitos sob o pressuposto "o avanço é $a$ ".

A computação fica em $p_{a}$ até $a$ ser transferido da entrada para a pilha. Depois dessa transferência é necessário tornar a consultar o avanço (em $p$ ) e proceder de acordo com o novo avanço.

O símbolo $#$ marca o fím da entrada e é processado de acordo com esse pressuposto. Por exemplo, não há transições de $p_{#}$ para $p$ e só neste estado pode ocorrer a ação aceitar.

Continuando o exemplo anterior, a transição do APR LR(1) tem as seguintes arestas:

iniciar transições $p_{I} ⊢ p$ : $λ, λ / 0$ .
avançar $terminal a b # de p p p aresta a, λ / λ b, λ / λ #, λ / λ para p_{a} p_{b} p_{#}$
transferir $AIV 2 ⊢ a 3 2 ⊢ b 4 5 ⊢ a 6 APR: de p_{a} p_{b} p_{a} APR: aresta λ, 2 / 3 a 2 λ, 2 / 4 b 2 λ, 5 / 6 a 5 APR: para p p p$
reduzir $AIV: estado 03456 AIV: item completo de A \neq = S^{'} A \to λ \cdot A \to A a \cdot A \to λ \cdot S \to A b A \cdot A \to A a \cdot AIV: avan \overset{c}{¸} os a, b a, b #, a # #, a AIV: computa \overset{c}{¸} \overset{a}{˜} o 0 0 ⊢ A 2 ⊢ a 3 4 0 ⊢ A 2 ⊢ b 4 ⊢ A 5 4 ⊢ A 5 ⊢ a 6 APR: aresta λ, 0 / 2 A 0 λ, 3 a 2 A 0 / 2 A 0 λ, 4 / 5 A 4 λ, 5 A 4 b 2 A 0 / 1 S 0 λ, 6 a 5 A 4 / 5 A 4$
aceitar $AIV: estado 1 AIV: item completo de S^{'} S^{'} \to S \cdot AIV: avan \overset{c}{¸} os # AIV: computa \overset{c}{¸} \overset{a}{˜} o 0 APR: aresta λ, 1 S 0 / λ$

que corresponde ao diagrama

Diagrama do APR LR(1)

As arestas $p \to p_{x}$ são avançar, $p_{x} \to p_{x}$ reduzir e aceitar e $p_{x} \to p$ são transferir.

Como é que este APR processa palavras? Por exemplo, $aba$ é gerada pela GIC, enquanto que $bab$ não.

Para $aba$ o APR tem a computação $estado p_{I} p p_{a} p_{a} p p_{b} p_{b} p p_{a} p_{a} p p_{#} p_{#} p_{#} p_{#} pilha λ 00 2 A 0 3 a 2 A 0 3 a 2 A 0 2 A 0 4 b 2 A 0 4 b 2 A 0 5 A 4 b 2 A 0 6 a 5 A 4 b 2 A 0 6 a 5 A 4 b 2 A 0 5 A 4 b 2 A 0 1 S 0 λ entrada aba # aba # ba # ba # ba # a # a # a # # # # λ λ λ λ pr \overset{o}{ˊ} ximo estado p p_{a} p_{a} p p_{b} p_{b} p p_{a} p_{a} p p_{#} p_{#} p_{#} p_{#} aresta λ, λ / 0 a, λ / λ λ, 0 / 2 A 0 λ, 2 / 3 a 2 b, λ / λ λ, 3 a 2 A 0 / 2 A 0 λ, 2 / 4 b 2 a, λ / λ λ, 4 / 5 A 4 λ, 5 / 6 a 5 #, λ / λ λ, 6 a 5 A 4 / 5 A 4 λ, 5 A 4 b 2 A 0 / 1 S 0 λ, 1 S 0 / λ a \overset{c}{¸} \overset{a}{˜} o iniciar avan \overset{c}{¸} ar reduzir A \to λ transferir avancar reduzir A \to A a transferir avan \overset{c}{¸} ar reduzir A \to λ transferir avan \overset{c}{¸} ar reduzir A \to A a reduzir S \to A b A aceitar (S^{'} \to S)$ que aceita e mostra a derivação $S \Rightarrow_{R} A b A \Rightarrow_{R} A b A a \Rightarrow_{R} A ba \Rightarrow_{R} A aba \Rightarrow_{R} aba$ . Quando à computação de $bab$ , rejeita:

$estado p_{I} p p_{b} p_{b} p p_{a} p_{a} p p_{b} pilha λ 00 2 A 0 4 b 2 A 0 4 b 2 A 0 5 A 4 b 2 A 0 6 a 5 A 4 b 2 A 0 6 a 5 A 4 b 2 A 0 entrada bab # bab # ab # ab # ab # b # b # b # # pr \overset{o}{ˊ} ximo estado p p_{b} p_{b} p p_{a} p_{a} p p_{b} \emptyset aresta λ, λ / 0 b, λ / λ λ, 0 / 2 A 0 λ, 2 / 4 b 2 a, λ / λ λ, 4 / 5 A 4 λ, 5 / 6 a 5 λ, λ / λ \emptyset a \overset{c}{¸} \overset{a}{˜} o iniciar avan \overset{c}{¸} ar reduzir A \to λ transferir avan \overset{c}{¸} ar reduzir A \to λ transferir avan \overset{c}{¸} ar rejeitar$

Com este exemplo termina a resolução do Problema Principal de ALP — Dada uma linguagem $A$ e uma palavra $p$ no mesmo alfabeto, determinar se $p \in A$ de forma computável, eficiente e adequada.

A linguagem é adequada se for formalmente definida por uma GIC LR(1).

Dada uma GIC que gere a linguagem, a construção algorítmica do seu AIV LR(1) é eficiente.

Pode-se verificar algoritmicamente e de forma eficiente se a GIC é LR(1), confirmando que nenhum estado do seu AIV LR(1) tem contradições. Nesse caso a linguagem é adequada.

A construção do APR LR(1) a partir do AIV LR(1) é, também, algorítmica e eficiente.

Dada uma palavra sobre o alfabeto da linguagem, o processamento pelo APR LR(1) é eficiente (e, claro, algorítmico). Adicionalmente, se a palavra está na linguagem, é possível recuperar a sua derivação na GIC para efeitos de processamento semântico.

Resumindo, este processo define um algoritmo (qua pode ser implementado em qualquer linguagem de programação comum) que é eficiente e resolve o Problema Principal de ALP.

Gramáticas LALR(1)

Neste ponto é fácil melhorar o seguinte problema: a construção do AIV gera muitos estados, o que pode ter um efeito negativo no desempenho dos restantes passos.

Quando dois estados do AIV têm os mesmos núcleos e, eventualmente, avanços distintos, a fusão consiste em juntar esses dois estados num único, cujos itens são obtidos:

os núcleos são os mesmos;

cada avanço é a união dos avanços dos itens correspondentes.

Usando um exemplo anterior

Diagrama do Autómato dos Itens LR(1) Válidos

Os estados $3$ e $6$ têm exatamente os mesmos núcleos.

O amalgamento deste AIV é

Autómato Amalgamado

O estado $36$ resulta de fundir $3$ com $6$ . Neste exemplo não há mais fusões possíveis.

Formalmente:

Autómato Amalgamado. Seja $A = (Q, Σ, δ, 0, F)$ um AIV LR(1).

Se $X = {q_{1}, \dots, q_{n}}$ for um conjunto de estados de $A$ com os mesmos núcleos, a fusão destes estados é o estado $X$ com os itens $(A \to u \cdot v, L_{1} \cup \dots L_{n})$ tais que $(A \to u \cdot v, L_{i}) \in q_{i}$ .

Seja ${Q_{1}, \dots, Q_{n}}$ uma partição de $Q$ tal que:

todos os estados de $Q_{i}$ têm os mesmos núcleos e

se $i \neq = j$ os núcleos dos estados de $Q_{i}$ e $Q_{j}$ são disjuntos. então

O autómato amalgamado $A^{'}$ é o autómato que resulta de fundir os estados com o mesmo conjunto de núcleos: $A^{'} = (Q_{A}, Σ, δ^{'}, {0}, Q_{A} ∖ {{\emptyset}})$ com

estados de controlo $Q_{A} = {Q_{1}, \dots, Q_{n}}$ .

transição $δ^{'} (Q_{i}, a) = Q_{j}$ se existe $q \in Q_{i}$ tal que $δ (q, a) \in Q_{j}$ .

Os autómatos amalgamados definem uma classe de gramáticas distinta de LR(1):

Gramática LALR(1). Uma GIC é LALR(1) se o seu autómato amalgamado satisfaz as condições LR(1): não tem conflitos redução/redução nem redução/transferência.

O principal interesse das gramáticas LALR(1) é, essencialmente, prático: Intuitivamente, são as gramáticas com "bons" AIV depois de amalgamados.

Exercícios — Análise Sintática

Os exercícios assinalados com "✓" serão resolvidos nas aulas práticas; Os assinalados com "†" têm elevada dificuldade. Todos os restantes devem ser resolvidos pelos alunos.

Exercícios — Análise Sintática

Limpeza de uma Gramática

Exercício 01

Considere a gramática independente do contexto $G = ({S, B, C}, {a, b, c}, P, S)$ com produções $S B C \to a S ∣ b S ∣ B \to bb ∣ C ∣ λ \to c C ∣ λ$

Escreva uma expressão regular que represente a linguagem gerada por $G$ .
Construa uma gramática (essencialmente) não contraível equivalente.
Elimine as produções unitárias da gramática obtida na alínea anterior.

Exercício 02

Repita o exercício anterior para a gramática:

$G = ({S, A, B, C}, {a, b, c}, P, S)$ com produções

$S A B C \to A BC ∣ λ \to a A ∣ a \to b B ∣ A \to c C ∣ λ$
$G = ({S, A, B}, {a, b}, P, S)$ com produções

$S A B \to BS A ∣ A \to a A ∣ λ \to B ba ∣ λ$

Exercício 03

Construa uma gramática equivalente a $G = ({S, A, B, C}, {a, b, c}, P, S)$ , com produções $S A B C \to A ∣ B ∣ C \to aa ∣ B \to bb ∣ C \to cc ∣ A$ que não contenha produções unitárias e escreva uma expressão regular que represente a linguagem gerada por esta gramática.

Exercício 04

Construa uma gramática equivalente a $G = ({S, A, B, C, D, E, F, G}, {a, b}, P, S)$ , com produções $S A B C D E F G \to a A ∣ B D \to a A ∣ a A B ∣ a D \to a B ∣ a C ∣ BF \to B b ∣ a A C ∣ E \to b D ∣ b C ∣ b \to a B ∣ b C \to a F ∣ a G ∣ a \to a ∣ b$ sem símbolos inúteis e encontre uma expressão regular que represente a linguagem gerada por esta gramática.

Exercício 05

Construa uma gramática equivalente a $G = ({S, A, B, C}, {a, b, c}, P, S)$ , com produções $S A B C \to a A b B ∣ A BC ∣ a \to a A ∣ a \to b B c C ∣ b \to ab c$ na forma normal de Chomsky.

Exercício 06

✓ Construa uma gramática equivalente a $G = ({E, S, T}, {a, b, -}, P, E)$ , com produções $E S T \to S \to T ∣ S - T \to a ∣ b$ na forma normal de Greibach.

Exercício 07

Repita o exercício anterior para a gramática

Com produções $A B \to a A b ∣ B \to B b ∣ λ$
Com produções $S A B \to A ∣ B \to AAA ∣ a ∣ B \to BB b ∣ b$

Gramáticas LL(k)

Exercício 08

Calcule os símbolos diretores e determine se as seguintes gramáticas são $LL (1)$ :

$G_{1} = ({S, A, B}, {a, b, c, #}, {S \to A B #, A \to a A b ∣ B, B \to a B c ∣ λ}, S)$
$G_{2} = ({S, A, B, C}, {a, b, c, d, #}, {S \to A BC #, A \to a A ∣ λ, B \to b B c ∣ λ, C \to c A ∣ d B ∣ λ}, S)$
✓ $G_{3} = ({S, A, B, C, D}, {a, b, c, d, #}, {S \to a A d #, A \to BC D, B \to b B ∣ λ, C \to c C ∣ λ, D \to b D ∣ λ}, S)$

Exercício 09

†✓ Modifique a gramática $G = ({S, A, B, C}, {a, b, c, #}, P, S)$ de modo a obter uma gramática $LL (1)$ equivalente. As produções de $G$ são: $S A B \to A # \to a B ∣ A b ∣ A c \to b B c ∣ λ$ Sugestão: Comece por determinar $L (G)$ .

Exercício 10

Repita o exercício anterior para a gramática $S A B C \to a A # ∣ ab B # ∣ ab c C # \to a A ∣ λ \to b B ∣ λ \to C c ∣ λ$

Exercício 11

Defina uma gramática $LL (1)$ que gere a linguagem das expressões aritméticas com subtração, multiplicação e parêntesis. (Use o símbolo $n$ para representar os inteiros.)

Gramáticas LR(0)

Exercício 12

Determine os $contexto- L R (0)$ da gramática com produções

$S A B \to a A ∣ b B \to ab A ∣ b B \to b B c ∣ b c$

$S A B \to a A ∣ a B \to a A b ∣ b \to b B a ∣ b$

Exercício 13

✓ Considere a gramática $G = ({S, A, B}, {a, b, #}, {S \to a B A #, A \to b ∣ a B, B \to a ∣ b B}, S)$ .

Construa o autómato dos itens válidos de $G$ .
Diga, justificando, se $G$ é $L R (0)$ .
Construa a tabela de análise sintática para $G$ .
Defina o autómato de pilha reconhecedor $L R (0)$ para $G$ .

Exercício 14

Repita as duas primeiras alíneas do exercício anterior para a gramática $G = ({S, A, B}, {a, b, #}, {S \to a A # ∣ A B #, A \to a A b ∣ b, B \to ab ∣ b}, S)$ Se concluir que a gramática não é $L R (0)$ , enumere os conflitos encontrados.

Exercício 15

Repita o exercício anterior para a gramática $G = ({X, Y, Z}, {0, 1, #}, {X \to Z Y # ∣ 1 Y Z #, Y \to 0 Y ∣ λ, Z \to Z 1 ∣ 1}, X) .$

Gramáticas LR(1)

Exercício 16

✓ Considere a gramática $G = ({S, A, B}, {a, b}, P, S)$ , com o conjunto de produções: $S A B \to A B \to a A ∣ λ \to B b ∣ λ$

Construa o autómato dos itens $L R (1)$ válidos de $G$ .
Diga, justificando, se $G$ é $L R (1)$ .
Construa o autómato amalgamado e diga, justificando, se $G$ é $L A L R (1)$ .
Construa a tabela de análise sintática $L R (1)$ para $G$ .
Com base no autómato dos itens válidos de $G$ , defina o autómato de pilha reconhecedor $L R (1)$ .
Construa a computação do autómato de pilha para a palavra $aabb$ .

Resolução em Banda Desenhada

AIV	TAS	APR

Exercício 17

✓ Repita o exercício anterior com a gramática $G = ({S, A, B}, {a, b}, P, S)$ , com o conjunto de produções: $S A B \to A B A \to A a ∣ λ \to b B ∣ b$

Exercício 18

✓ Repita as primeiras 4 alíneas do exercício anterior com a gramática $G = ({S}, {a}, P, S)$ , com o conjunto de produções: $S \to a S a ∣ λ$ (Se $G$ não é $L R (1)$ , não faça as alíneas que não se aplicam.)

Exercício 19

Repita o exercício anterior com as gramáticas

$G = ({S, E, F}, {w, x, y, z}, P, S)$ , com o conjunto de produções:

$S E F \to E x ∣ y Ew ∣ Fw ∣ y F x \to z \to z$

$G = ({S, C}, {c, d}, P, S)$ , com o conjunto de produções:

$S C \to CC \to c C ∣ d$

$G = ({E, T}, {i, +, (,)}, P, E)$ , com o conjunto de produções:

$E T \to E + T ∣ T \to i ∣ (E)$

Implementação

As indicações gerais para os exercícios de implementação são válidas aqui.

Uma biblioteca para Grafos Orientados, com Pesquisas

Para este grupo de exercícios pode usar, entre outros, os grafos indicados a seguir.

# Grafos para testar as implementações.
simples = [
  (0, 2),
  (1, 3),
  (2, 0),
  (3, 1),
]

cubo = [
  (0, 1), (0, 4),
  (1, 2), (1, 5),
  (2, 3), (2, 6),
  (3, 0), (3, 7),
  (4, 5), (5, 6), (6, 7), (7, 4)
]

cubo_inclinado = [
  (0, 1), (0, 3), (0, 4),
  (1, 2), (1, 5),
  (2, 6),
  (3, 7),
  (4, 5), (4, 7),
  (5, 6),
  (7, 6)
]

Represente. Uma aresta orientada $a \to b$ por um tuplo (a, b).
Represente. Um Grafo (orientado) por uma lista de arestas.
Implemente. A função nodes(graph) que devolve o conjunto do vértices do grafo.
Implemente. A função children(graph, node) que devolve o conjunto dos filhos do vértice node.
Implemente. A função parents(graph, node) que devolve o conjunto dos pais do vértice node.
Implemente. A função is_path(graph, path) que testa se path é um caminho no grafo graph. Um caminho é uma lista de vértices em que dois consecutivos estão ligados por uma aresta.
Implemente. A função has_loop(graph, path) que testa se path tem algum ciclo no grafo graph. Um ciclo é um caminho que começa e termina no mesmo vértice.
Implemente. A função search(graph, a, b) de acordo com os apontamentos teóricos. Considere uma variante em que as funções expand e join são passadas como argumentos opcionais. Verifique o que acontece se não controlar os vértices visitados.
Teste. Pesquisas ascendentes, descendentes, em largura e em profundidade.

Uma biblioteca para Árvores, com Pesquisas

Represente. Um nó/vértice é representado pela estrutura Node com atributos:
- value: Qualquer "coisa" que pode estar no nó.
  - Obs. nem todas as linguagens permitem isto facilmente. Em python e kotlin, por exemplo, é direto.
- children: Uma lista de Node.
  - Obs. esta recursividade também levanta problemas em algumas linguagens. Por exemplo, em rust terá de fazer algo do género Vec<Box<Node>>. Em python não terá qualquer dificuldade.
Implemente. A função leaf(value) cria uma folha (isto é, um nó sem filhos).
Implemente. A função binop(op, lhs, rhs) cria um nó com value op e dois filhos: lhs e rhs. Considere variantes em que lhs, rhs são Node ou são um tipo qualquer.
Implemente. A função node(value, children) aceita um número variável de valores em children. Por exemplo node("plus", 3, 4, 5) e não node("plus", [3, 4, 5]).
Escrita. A função repr(node) devolve uma string com a representação de uma árvore, um valor por linha. Indente os descendentes. Por exemplo:

plus
- 3
- times
  - 4
  - 5

Alternativamente, as árvores podem ser representadas por listas de listas. Por exemplo:

("plus" 3 ("times" 4 5)) =
("plus"
    3
    ("times"
        4
        5
))

Desta forma, em geral n = Node(value, children) define a lista [n.value] + CHILDREN em que CHILDREN é a lista das representações dos nós em n.children.

N.B. usando a notação do python, tree.children = tree[1:] e tree.value= tree[0]. Além disso, a representação das folhas é o próprio valor, não uma lista.

Pesquisa:

Implemente. A função search para pesquisas (em profundidade e em largura).
- Começe com pesquisas por valor exato: Por exemplo, search(tree, value) procura em tree um nó n tal que n.value == value. No caso de existir um nó nessas condições, devolve o caminho para esse nó.

Caminhos para nós descendentes. Por exemplo, se tree for o exemplo acima, o caminho para chegar ao nó com o valor 4 é a lista [1, 0] porque começando na raiz (o nó com valor plus) escolhe-se o filho na posição 1 (o nó com valor times e filhos [4, 5]) e, desse nó escolheu-se o filho na posição 0; Isto é, o caminho [0, 1] indicas os indices dos filhos escolhidos, quando se "desce" a árvore.

O caminho para chegar ao valor 5 seria [1, 1] e para chegar a times seria apenas [1]. Finalmente [0] dá o valor 3 e o caminho [] leva ao valor ... (exercício).

Implemente. A função subtree(tree, path) devolve o nó que corresponde ao caminho path. Se não existe tal nó, devolve "não definido".
Generalize. Há várias generalizações interessantes:
- Use um predicado em vez de um valor. Por exemplo, para encontrar um nó com o valor par: tree.searchD(lamba x: x.value % 2 == 0).
- Encontre todas as ocorrências em vez de apenas uma. Ou encontre até n ocorrências. Por exemplo: tree.search(lambda x: len(x.children) > 2, n=42) para encontrar 42 nós com mais do que dois filhos. Convencione que, se n for "não definido" procura todas as ocorrências.
  - A pesquisa de todas as soluções também tem um tratamento interessante que consiste em implementar a pesquisa como uma stream que produz um novo nó sempre que solicitada. No caso do python pode usar yield. Noutras linguagens, ymmv.
- Implemente outras estratégias de pesquisa. Por exemplo a Iterative deepening depth-first, é uma forma melhorada de pesquisas em profundidade.

Analisadores LL(1)

Considere a GIC

$E x p r \to a t o m ∣ (S e q) S e q \to λ ∣ E x p r S e q$ em que os terminais são $a t o m, ($ e $)$ .

Verifique (manualmente) se é LL(1) e, nesse caso, implemente um analisador sintático LL(1). A função parse(s) tem como argumento a string s e devolve uma árvore.

Comece por separar (tokenize) a palavra numa lista de símbolos.
Precisa de um "contexto" de processamento com:
1. O símbolo seguinte: next.
2. A lista dos símbolos que faltam processar.
3. A função consume(symbol).
Processe a lista de tokens usando as funções proc_Expr(token, tokens, tree) e proc_Seq(token, tokens, tree):
- token é o símbolo de avanço.
- tokens são os restantes símbolos da palavras (incluindo token).
- tree é a árvore que resulta do processamento da função.
Vai precisar de funções auxiliares como consume(token, tokens)

Uma biblioteca para GIC LL(1)

Se resolver sozinho estas alíneas ganha o direito de se gabar nas aulas de ALP durante uma semana. E o dever de ajudar os seus colegas.

‡ Implemente. O método firsts() que devolve um mapa do tipo symbol: set<symbol> que associa a cada símbolo (variável ou terminal) da gramática o conjunto dos seu primeiros.

‡ Implemente. O método follow() que devolve um mapa do tipo symbol: set<symbol> que associa a cada símbolo (variável ou terminal) da gramática o conjunto dos seu seguintes.

Análise Sintática LL(1)

Implemente. O método firsts_of(symbol) devolve o conjunto dos primeiros de symbol.
Implemente. O método follow_of(symbol) devolve o conjunto dos seguintes de symbol.
Implemente. O método directors(rule) devolve o conjunto de diretores da regra rule.
Teste. O método is_LL1() testa se grammar é LL(1).

Uma biblioteca para GIC LR

Itens

Represente. Um item LR(1) é representado pela classe Item com atributos:
- rule uma regra.
- lookahead uma lista de símbolos.
- position um inteiro, que indica a posição do "ponto".
Teste. O método is_complete() testa se o item é completo.
Implemente. O método active_prefix() devolve o prefixo até à posição do "ponto".
Implemente. O método active_symbol() devolve o símbolo imediatamente a seguir ao ponto se o item não for completo e "não definido" caso contrário.
Implemente. O método active_suffix() devolve o sufixo desde a posição a seguir ao "ponto".
- N.B: active_prefix + active_symbol + active_suffix deve reconstruir o lado direito da produção.
Implemente. O método transition(symbol) devolve o item que resulta de "ler" symbol. Isto é, se symbol == active_symbol no novo item o "ponto" avança uma posição. Caso contrário devolve "não definido".
Escrita. O método __repr__() devolve uma string da forma C〈V → P · A S ⎅ L〉 em que:
- C é "'★'" quando o item é completo e vazia ('') caso contrário.
- V é o lado esquerdo da produção.
- P, A e S são o prefixo, símbolo e sufixo ativos.
- L é a lista dos símbolos de avanço, separados por espaços. Se for vazia, use ∅.
- Use mesmo os símbolos indicados: ★〈→·⎅∅〉

Análise Sintática, Autómato dos Itens Válidos

Na biblioteca para os AFD estes são construídos com uma lista de transições, o estado inicial e uma lista de estados finais. Além disso, os estados são inteiros.

Mas, na construção do Autómato dos Itens Válidos os estados "contêm" conjuntos de itens. Esta diferença é resolvida mantendo uma associação (mapa, dicionário) dos estados do AFD para os conjuntos de itens. A vantagem é que não é preciso mudar a implementação dos AFD. A desvantagem é que se torna necessário fazer alguma "manutenção" dessa associação.

Representação. Uma classe VIA com atributos:
- grammar a gramática.
- fsa o autómato dos itens válidos calculado para grammar.
- states a associação dos estados do autómato para os conjuntos de itens.
- table a tabela de análise sintática, uma associação dos estados+avanços do autómato para reduções/transferências.
- phase um inteiro (ou enum) para marcar a fase de processamento: INITIAL = 0 → GRAMMAR_OK → START_OK → VIA_OK → TABLE_OK. Se algum destes passos correr mal → ERROR.
Construção. O método make_VIA(). Se grammar.is_valid() incrementa phase.
† Implemente. O método calc_startCore() que calcula o núcleo do estado inicial de via. Devolve um conjunto de itens.
† Implemente. O método close(itens) que calcula o fecho de um conjunto de itens. Devolve um conjunto de itens.
Implemente. O método build_START() que calcula o estado inicial de via. Se correr bem incrementa phase.

Se resolver sozinho todas as alíneas seguintes ganha o dever de ajudar os seus colegas. E o direito de se gabar nas aulas de ALP durante uma semana.

† Implemente. O método build_FSA() processa grammar para definir o autómato fsa, a associação states e is_built. Se correr bem incrementa phase.
† Implemente. O método build_TABLE() processa grammar, fsa e states para definir table. Se correr bem incrementa phase.

† Implemente. O método derive(word) para encontrar uma derivação de word pela gramática via.grammar. N.B. não é necessário implementar autómatos de pilha.
† Implemente. O método derivation_tree(word) que calcula a Árvore de Derivação de word.
Controlo. Use phase para evitar computações repetidas, precoces ou desnecessárias. Por exemplo, suponha que houve um erro a calcular o estado inicial. Então quando "chama" build_FSA deve evitar calcular o AFD. Por outro lado, se já calculou fsa com sucesso e "acidentalmente" chama build_FSA não há razão para repetir esses cálculos.
- Também pode usar phase para implementar cálculos build--- "inteligentes" (Ah! Ah!). Suponha que "chama" build_TABLE mas phase < VIA_OK. Nesse ponto pode chamar build_VIA que por sua vez faz uma análise semelhante.

Representação e Processamento de Programas

Este capítulo inspira-se em grande parte (e copia pontualmente) no artigo (How to Write a (Lisp) Interpreter (in Python)) de Peter Norvig, cuja leitura se recomenda.

Introdução

Introdução
- Representação de Programas e/ou Expressões

Procura-se ilustrar uma das principais aplicações da análise sintática: A implementação de linguagens de programação.

Antes de se definir a própria linguagem de programação e considerar os aspetos da implementação do respetivo analisador sintático e do interpretador faz-se uma revisão dos termos e processos envolvidos.

Alguns termos relevantes, alguns já familiares, são:

Símbolos: "entidades" indivisíveis e distintas entre si. Um conjunto de símbolos é um alfabeto.
Palavra: sequência finita de símbolos.
Linguagem: conjunto de palavras.
Gramática: regras que permitem especificar certas linguagens.
Representação: descrição da estrutura duma palavra, de acordo com uma gramática.

Também é importante recapitular alguns processos:

A análise sintática consiste em decidir de uma palavra $p$ está, ou não, numa linguagem $L$ : " $p \in L$ ?". No caso da linguagem ser gerada por uma certa gramática $G$ , isto é, se $L = L (G)$ , a questão da análise sintática passa a ser " $S \Rightarrow * p$ ?" em que $S$ é o símbolo inicial de $G$ .
Para o processamento de programas, em particular para a interpretação e/ou compilação, não basta saber que $S \Rightarrow * p$ ; É mais importante representar a estrutura de $p$ de acordo com as regras de $G$ . Essa representação pode ser, por exemplo, a árvore da derivação de $p$ ou a sua própria derivação, isto é a sequência de regras aplicadas passo-a-passo em $S \Rightarrow * p$ .
A representação do programa é processada pelo interpretador, que mantém uma configuração interna, atualizada conforme a computação avança nas instruções.
A evolução da computação depende, por um lado, dos tipos das instruções e, por outro, dos valores das expressões.

Representação de Programas e/ou Expressões

É necessária uma estrutura de dados adequada à representação e ao processamento de programas.

Começando pelas expressões algébricas:

Árvore de Derivação	Árvore Simplificada	Valoração da Expressão

A palavra 2 + (3 * 4) representa a expressão algébrica $2 + (3 \times 4)$ mas, como "simples" sequência de símbolos, perde-se a estrutura da expressão que representa.
As sequências (isto é, listas) não são adequadas para processar expressões ou programas. Por exemplo, para calcular o valor de $2 + (3 \times 4)$ primeiro avalia-se a parte $3 \times 4$ e depois esse resultado é somado a $2$ .
A estrutura da expressão algébrica resulta de uma certa gramática, implícita na respetiva definição formal.
A linguagem das expressões algébricas resulta, por exemplo, da seguinte GIC:
```
E → E + T | E - T | T
T → T * U | T / U | U
U → N | V | ( E )
```
em que N define números (-1, 2.45E-5, 42.021, etc) e V variáveis (a, Largura, etc).
De acordo com esta GIC a palavra 2 + (3 * 4) tem a Árvore de Derivação acima.
Na Árvore Simplificada a representação em árvore permite calcular o valor da expressão, propagando os valores das folhas para a raíz e, em cada nó, aplicando a operação adequada conforme o tipo do nó.
A implementação de árvores por uma estrutura de dados é assunto doutras disciplinas. Aqui estamos interessados numa representação simples de árvores, de preferência sem a introdução de novos tipos, operações, etc
A árvore simplificada fica representada (em Python) pelo tuplo ('+', 2, ('*', 3, 4)).
Em geral, cada nó tem um conteúdo X e descendentes D1, ..., Dn. Este nó é representado pelo tuplo (X, D1, ..., Dn) com a convenção de que as folhas (Z) são representadas apenas por Z.
Subindo a árvore de 2 + (3 * 4) temos:
1. Folhas 2, 3 e 4 (e não (2) por exemplo).
2. A multiplicação é o tuplo ('*', 3, 4) porque o respetivo conteúdo é '*' (uma string Python) e tem dois descendentes, 3 e 4.
3. O nó da soma tem conteúdo '+' e dois descendentes, a folha 2 e a sub-árvore ('*', 3, 4). Fica representado por ('+', 2, ('*', 3, 4)).

Esta forma de representar as (estruturas das) expressões vai ser aplicada à representação (das estruturas) dos programas.

Também o exemplo do cálculo do valor da expressão algébrica orienta a implementação do interpretador.

Desenho de uma Linguagem de Programação

Desenho de uma Linguagem de Programação
- Lisp
- Semântica Informal da ALisP

Como já está esboçado um esquema geral para representar programas, agora pode-se tratar da linguagem propriamente dita.

O que se pretende e/ou necessita numa linguagem de programação?

Em geral, numa linguagem de programação encontra-se:

Expressões e Variáveis.
Instruções e Sequências.
Condicionais.
Ciclos.
Funções.
Entrada/Saída.

Mais especificamente,

Expressões e Variáveis. As expressões definem os valores que os programas processam e as variáveis "mantêm" esses valores para uso posterior.

Por exemplo, a instrução a = 2 + (3 * 4) em Python define um certo valor que fica guardado na variável a e que pode ser usado posteriormente, como em a % 2 == 0.

Instruções e Sequências. Um programa é uma sequência (ou bloco) de instruções. "Correr" um programa significar avançar uma instrução de cada vez ao longo dessa sequência.

São comuns certas convenções sobre as sequências que "efetivamente" definem um programa. Por exemplo, em C o programa é o bloco de instruções que está na função main e tudo o resto é "auxiliar".

Condicionais. Um condicional permite certas condições ativarem e desativarem blocos de instruções.

A sintaxe mais comum dos condicionais é if (C) A else B com pequenas variantes conforme a linguagem.

Ciclos. Um ciclo repete um certo bloco de instruções em função de uma condição.

Quando o número de repetições é conhecido de antemão é comum usar-se a sintaxe for(i = 0; i < n; i++) A para repetir n vezes as instruções de A.

Quando as repetições estão dependentes de uma condição, a forma while (C) A, que testa C e repete A enquanto a condição C for verdadeira, é comum.

Também se usa a forma do A while (C), que corre A pelo menos uma vez, antes de testar C.

Funções. As funções são uma forma simples de evitar repetição de código e de acrescentar instruções "novas" a uma linguagem de programação.

Se for necessário calcular 2 + 2, 2 + 3, 2 + 4, ..., 2 + 42 não se escrevem 40 instruções quase iguais. Define-se uma função que mantém a parte comum do código repetido e usa variáveis locais para os valores que variam. Sendo possível, a função pode ser evocada num ciclo.

Funções Anónimas. Formalmente, uma função não precisa de ter um nome. Nalgumas linguagens mais arcaicas, como o C, as funções anónimas (ou lambdas) não são suportadas diretamente. Com a maior disponibilidade do processamento de coleções têm ganho popularidade. Por exemplo, em Java foi introduzido o operador ->, o Javascript e o C# têm o =>, no Python usam-se expressões lambda e no Rust a sintaxe é |var| instr, etc. TL/DR: As funções anónimas são fixes.

Entrada/Saída. Um programa, enquanto processador de informação precisa de canais de entrada e de saída de dados.

As formas mais simples de entrada e saída de dados pressupõem uma consola onde o utilizador digita e lê os dados que, respetivamente, dão entrada no, ou são escritos pelo, programa.

Lisp

O Lisp é uma das mais antigas, influentes e avançadas linguagens de programação.

Tanto que há, não um mas, dois `xkcd` obrigatórios!!


Dois `xkcd` sobre o mesmo assunto é... incomum.

Além disso, all the programming languages converge to Lisp e any sufficiently complicated program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.

Aspeto de um programa Lisp (especificamente, Common Lisp):

(defun fib (x)
    (if (< x 2)
        1
        (+ (fib (- x 1)) (fib (- x 2)))
    )
)
(fib 6) ; resultado: 13

A "excecionalidade" do Lisp está nas possibilidades que resultam da sua simplicidade. "Elegant weapons" significa que certas ideias muito simples são extremamente efetivas. Por exemplo, (+ 41 1) é uma lista com três elementos, uma expressão que vale 42 e uma (instrução de) evocação da função +.

Lisp significa LISt Processor. Além dos tipos básicos (inteiros, doubles, strings) tem listas. Ao contrário dos array em muitas linguagens, uma lista do Lisp pode ter elementos de tipos diferentes. Por exemplo, (42 3.14 "fourty-two" ("sub" lista)).
No Lisp as instruções também são expressões. Isto é, (+ 2 (* 3 4)) é simultaneamente uma expressão (com valor 12) e uma instrução (neste caso, evocar a função "+").
- Por exemplo, um condicional é (if C A B) e, como C, A e B são expressões, o valor do condicional é o valor do ramo que foi seguido.
A sintaxe segue fielmente a representação das árvores feita acima (as vírgulas são descartadas). Isto é: Um programa Lisp é a sua própria representação! É possível um programa Lisp ler, analisar e modificar o seu próprio código enquanto corre. Em particular, o Lisp é homoicónico.

No resto deste capítulo define-se uma linguagem de programação, ALisP, inspirada no Lisp. Além das propriedades acima, acresce ainda que a gramática para a sintaxe é extremamente simples e LL(1), o que permite implementar (quase) diretamente um analisador sintático.

Semântica Informal da `ALisP`

Uma antevisão daALisP.

Variáveis e Expressões: (set a (+ 30 12)) define a variável a e dá-lhe o valor 42. A expressão completa também fica com esse valor.
Instruções e Sequências: (seq (set a (+ 40 10)) (set a (- a 8))) executa as duas instruções. Fica com o mesmo valor que a última sub-expressão.
Condicionais: (if (== a 42) CERTO (> 0 1)) calcula o valor de (== a 42); Se for True calcula e fica com o mesmo valor que CERTO; Caso contrário calcula (> 0 1) e fica com esse valor.
Ciclos: (while (< a 42) (set a (+ a 1))) repete o "passo" (set a (+ a 1)) enquanto a condição (< a 42) for verdadeira. Quando (se) termina fica com o valor do "passo".
Funções (anónimas): (fn (x) (== x 42)) define uma função anónima com argumentos x e "corpo" (== x 42). A variável x está limitada ao "corpo" da função. Devolve o valor do "corpo" quando x tem o valor com que a função é evocada. Por exemplo, em
```
(seq
    (set dobro (fn (x)
        (* 2 x)
    ))
    (dobro 21)
)
```
a evocação (dobro 21) define o valor de x como 21 e, portanto, a função devolve (surpresa!) 42.
Entrada/Saída: (read) é uma forma especial. Tem o valor que o utilizador escrever na consola; (write 42) esteve 42 na consola. Tem o valor da expressão que é escrita.

Um programa ALisP simples, que pergunta o nome do utilizador e o cumprimenta:

(seq
    (write (What is your name?))
    (set name (read))
    (Hello name .)
)

Um defeito semântico da atual versão da ALisP é que os símbolos, como em What is your name? são tratados como string, o que simplifica a implementação mas torna o código mais imprevisível. Por exemplo, o valor de (Hello name .) varia conforme name é, ou não, uma variável e esse facto não pode ser deduzido olhando apenas para esta expressão.

Analisador Sintático com Representação

Embora a função principal da análise sintática seja determinar se p ∈ L(G), aqui pretende-se ir além dessa resposta e obter a representação de p em termos da sua árvore (simplificada) de derivação na gramática G.

Gramática `ALisP`

Em termos de sintaxe a linguagem é a linguagem dos parêntesis equilibrados, com átomos, definida pela seguinte gramática, que designamos ALisP:

Expr -> atom | ( Seq )
Seq -> λ | Expr Seq

onde atom representa um terminal átomo isto é, uma "palavra contígua": uma string não vazia sem espaços nem parêntesis.

Os átomos podem (devem!) ser representados pela sua própria sub-gramática. Para o efeito pretendido (análise sintática com representação) esse exercício iria apenas acrescentar ruído. Em vez disso, é implementado o teste is_atom(x), posteriormente usado pelo analisador sintático.

Para implementar o analisador sintático LL(1) é preciso calcular os diretores de cada produção.

Geradores de λ

Λ
`Seq`

Primeiros e Seguintes

Variável	Primeiros	Seguintes
`Expr`	`atom`, `(`	`atom`, `(`, `)`
`Seq`	`atom`, `(`	`)`

Diretores

Produção	Diretores
`Expr -> atom`	`atom`
`Expr -> ( Seq )`	`(`
`Seq -> λ`	`)`
`Seq -> Expr Seq`	`atom`, `(`

A tabela dos Diretores indica que a gramática ALisP é LL(1), pelo que pode ser aplicado o método dado no respetivo capítulo para construir um analisador sintático. Porém, também se pretende obter a representação da (árvore simplificada da derivação da) palavra.

Representação de Árvores

Como já foi tratado acima, qualquer árvore pode ser representada em Python por tuple aninhados. Mais especificamente:

Representação de nós em Python. O nó com com conteúdo x e descendentes d1, ..., dn, em que x e os di são valores Python, é representado pelo tuple
(x, d1, ..., dn)
Por convenção a representação das folhas não usa parêntesis. Em vez de (x) usa-se apenas x.

Por exemplo, a árvore de 2 + (3 * 4) é representada por

('+', 2, ('*', 3, 4))

Analisador Sintático com Representação

O analisador sintático com representação é implementado a partir da base definida no capítulo sobre a análise sintática LL(1). Acrescenta-se uma forma de se obter a representação em árvore e de tratar da especificidade dos átomos.

Para a implementação do analisador sintático compensa considerar com algum detalhe o contexto em que a análise LL(1) decorre. Em particular, importa tratar rigorosamente o processamento do avanço, de consumir e dos erros.

Contexto LL(1) Especificamente, uma instância c da classe ContextLL1:

É construída com a palavra a ser analisada.

c.next() devolve o próximo símbolo da palavra, se existir; caso contrário devolve None.

c.consume(x) consome o próximo símbolo se o valor deste for x; caso contrário levanta uma exceção.

c.error(m) levanta uma exceção com a mensagem m.

Adicionalmente, c.is_complete() testa se não existe seguinte.

class ContextLL1:
    """Tracks and supports the state of a LL1 parsing process."""
    def __init__(self, word):
        self.word = word
        self.pos = 0

    def is_complete(self):
        """Checks if the parsing process is complete."""
        return self.pos >= len(self.word)

    def next(self):
        """Returns the next (unread) token."""
        if not self.is_complete():
            return self.word[self.pos]
        else:
            return None

    def consume(self, symbol):
        """'Consumes' symbol, advancing if possible."""
        if not self.is_complete() and self.next() == symbol:
            self.pos += 1
        else:
            self.error(f"** ERROR ** Can't CONSUME '{symbol}' while expecting '{self.next()}'.")

    def error(self, message):
        """Error handling."""
        raise Exception(f"{message}\nWord: {self.word}\nRead: {self.word[self.pos:]}\nUnread: {self.word[:self.pos]}")

    def __repr__(self):
        """String representation."""
        return f"\"{' '.join(self.word[:self.pos])}\" | \"{' '.join(self.word[self.pos:])}\""

Suporte. São necessárias algumas funções de suporte. Em particular

tokenize(text) aceita uma string e devolve a lista das sub-palavras separadas por espaços, com tratamento especial dos parêntesis.

is_atom(symbol) testa se symbol é um átomo: uma string não vazia e sem ocorrências de espaços ou parêntesis.

atom_value(atom) devolve o "valor" do átomo atom, conforme atom pode ser convertido num ìnt senão num float senão no próprio atom.

def tokenize(text):
    """
    Converts a string to a list of tokens.
    """
    text = ''.join(ch for ch in text if ch.isprintable())
    text = text.replace("(", " ( ").replace(")", " ) ")
    tokens = text.split(" ")
    tokens = [tok.strip() for tok in tokens]
    tokens = [tok for tok in tokens if len(tok) > 0]
    return tokens

def is_atom(symbol):
    """
    Tests if a symbol is an atom.
    """
    return isinstance(symbol, str) and \
        len(symbol) > 0 and \
        (not ' ' in symbol) and \
        (not '(' in symbol) and \
        (not ')' in symbol)

def atom_value(atom):
    """
    Gets the value of an atom. BAD BAD NOT GOOD CODE.
    """
    value = None
    try:
        value = float(atom)
        (d, i) = math.modf(value)
        value = int(i) if d == 0 else value
    except:
        value = atom
    return value

A implementação do analisador sintático, segundo o processo LL(1), consiste em definir uma função para cada variável da gramática ALisP e, em cada uma dessas funções, usar o avanço e os diretores para "percorrer" a regra adequada.
A implementação LL(1) base é aumentada de forma se obter uma representação parcial em cada função associada.
Todo o processo da análise sintática com representação é concretizado em parse(text). Esta função aceita como argumento text, uma string, e, se corresponder a uma palavra gerada pela gramática, devolve a respetiva representação em árvore.

#
# Rule            | Dir
# ----------------|-------
# Expr -> ( Seq ) | (
# Expr -> atom    | atom
#
def proc_Expr(context):
    next_symbol = context.next()
    if next_symbol == "(":
        context.consume("(")
        seq = proc_Seq(context)
        context.consume(")")
        return seq
    elif is_atom(next_symbol):
        context.consume(next_symbol)
        return atom_value(next_symbol)
    else:
        context.error(f"** ERROR ** Can't use Expr with next '{next_symbol}'.")
#
# Rule            | Dir
# ----------------|-------
# Seq -> Expr Seq | atom (
# Seq -> nil      | )
#
def proc_Seq(context):
    next_symbol = context.next()
    if is_atom(next_symbol) or next_symbol == "(":
        e = proc_Expr(context)
        s = proc_Seq(context)
        return (e,) + s
    elif next_symbol == ")":
        return tuple()
    else:
        context.error(f"** ERROR ** Can't use Seq with next '{next_symbol}'.")

def parse(text):
    word = tokenize(text)
    if all(is_atom(x) or x in "()" for x in word):
        context = ContextLL1(word)
        expr = proc_Expr(context)
        return expr
    else:
        return None

A implementação do processo de análise sintática chega ao fim da aplicação dos capítulos anteriores.

Recapitulando o que foi feito até aqui:

Definiu-se uma gramática para especificar a sintaxe da ALisP.

Essa gramática é LL(1) e implementou-se um analisador sintático que devolve uma representação em árvore da palavra dada.

Se tivesse sido escolhida uma linguagem com sintaxe mais complexa poderia ser necessário um analisador LR(1). Porém, o objetivo aqui é ir além da matéria anterior, implementando um interpretador da ALisP.

Interpretador

Interpretador

A análise sintática (da ALisP) fica isolada na função parse(text), que devolve uma árvore com a estrutura de text de acordo com a gramática ALisP. Por exemplo, parse("(+ 2 (* 3 4))") devolve ('+', 2, ('*', 3, 4)).

O passo seguinte consistem em associar um valor (a semântica) a cada representação (à sintaxe), de forma a construir a ALisP com as caraterísticas pretendidas. Nomeadamente, pretende-se que a ALisP tenha:

Expressões e Variáveis.
Instruções e Sequências.
Condicionais.
Ciclos.
Funções.
Entrada/Saída.

além de, é claro, certas funções base.

Para correr da forma esperada, um programa precisa de um certo "contexto" onde é mantida e atualizada informação sobre as variáveis. Por exemplo, no programa

(
    (set a 42)
    (set b (- a 2))
    (write (b a))
)

na primeira instrução é criada uma variável com nome a e valor 42 e na segunda instrução o valor de a é consultado, operado e o resultado define o valor da recém-criada variável b. Por fim, tanto o valor de b como de a são consultados para definir a lista (b a) que será escrita na consola.

Funções Base

As funções base definem cálculos "diretos" que dependem apenas dos valores dos argumentos e não afetam o contexto do programa.

Entre as funções base estão incluidas as operações aritméticas +, -, * e /; as relações de ordem <, >, <= e >=; de igualdade == e !=; as operações booleanas and, or e not; as funções trigonométricas sin e asin; e as funções para decompor listas head, tail e nth. A escolha das funções básicas deve corresponder às necessidades que levam ao desenvolvimento da linguagem de programação. Por exemplo, o octave é uma linguagem de manipulação de matrizes numéricas e tem pré-definidas as respetivas operações.

No âmbito da ALisP é suficiente definir as funções base como um dicionário Python onde o nome da função está associado a um tuple com a aridade e uma expressão lambda (isto é, a versão Python das funções anónimas):

import math
BASE_FUNCTIONS = {
    #
    # Aritméticas
    #
    '+': (2, lambda x, y: x + y),
    '-': (2, lambda x, y: x - y),
    '*': (2, lambda x, y: x * y),
    '/': (2, lambda x, y: x / y),
    #
    # Ordem
    #
    '>': (2, lambda x, y: x > y),
    '>=': (2, lambda x, y: x >= y),
    '<': (2, lambda x, y: x < y),
    '<=': (2, lambda x, y: x <= y),
    #
    # Igualdade
    #
    '==': (2, lambda x, y: x == y),
    '!=': (2, lambda x, y: x != y),
    #
    # Booleanas
    #
    'not': (1, lambda x: not x),
    'and': (2, lambda x, y: x and y),
    'or': (2, lambda x, y: x or y),
    #
    # Trigonométricas
    #
    'sin': (1, lambda x: math.sin(x)),
    'asin': (1, lambda x: math.asin(x)),
    #
    # Listas
    #
    'head': (1, lambda x: x[0]),
    'tail': (1, lambda x: x[1:]),
    'nth': (2, lambda n, x: x[n]),
}

Esta representação das funções base pode ser facilmente modificada de forma a proporcionar, à partida, instruções adequadas ao domínio que se pretende trabalhar. Por exemplo, para computação gráfica 2D as funções base podem incluir os controlos de uma "tartaruga", forward, turn, up, down e set_color.

Contexto

O contexto é, essencialmente, um dicionário que associa o nome de cada variável ao respetivo valor. Além disso, é necessário considerar que as funções definem variáveis locais mas também têm acesso às variáveis externas.

(seq
    (set x 21)
    (set dobro (fn (x)
        (* x 2)
    ))
    (set x (- x 1))
    (x (dobro 10))
)

a variável x é local e externa em dobro. Na última linha, (x (dobro 10)), tem o valor 20 no primeiro elemento e, quando a função dobro é evocada, é usado o valor local, 10, passado como argumento. O papel da instrução seq é esclarecido mais tarde.

A implementação do contexto é:

class ALisPContext:
    def __init__(self, outer):
        self.outer = outer
        self.local = dict()

    def defines(self, key):
        return key in self.local.keys() or key in self.outer.keys()

    def set(self, var_name, var_value):
        self.local[var_name] = var_value

    def keys(self):
        return self.local.keys() | self.outer.keys()

    def __getitem__(self, key):
        return self.value(key)

    def value(self, name):
        result = None
        #
        if name in self.local.keys():
            result = self.local[name]
        elif name in self.outer.keys():
            result = self.outer[name]
        elif name == 'True':
            return True
        elif name == 'False':
            return False
        elif is_atomic(name): # 42, -4.2, ola
            result = atom_value(name)
        #
        return result

ALisPContext Uma instância c de ALisPContext :

É construída em relação a um contexto "externo" (que pode ser o dicionário vazio, {}).

c.set(var_name, var_value) define uma associação da variável var_name ao valor var_value.

c.defines(key) testa se o nome key tem uma associação, local ou externa.

c.keys() devolve o conjunto das chaves, locais ou externas, conhecidas.

c[atom] ou c.value(atom) devolve, por ordem:

O valor associado a name se existe essa associação a) local ou b) no contexto externo.

Se name é "True" ou "False" os valores booleanos correspondentes.

Se name é atómico (de acordo com is_atom) o respetivo valor calculado por atom_value.

None.

O método interessante de ALisPContext é value que, além de obter os valores associados a uma variável local ou externa, ainda proporciona os valores dos átomos e das constantes booleanas.

Valoração

A valoração consiste em calcular o valor de uma representação, isto é, definir uma semântica da (representação) sintaxe.

Esse cálculo depende de um contexto, que mantém e atualiza os valores das variáveis.

Por exemplo, A palavra 2 + (3 * 4) tem representação ('+', 2, ('*', 3, 4)), obtida pelo analisador sintático. A esta representação corresponde o valor 14, que resulta de aplicar as respetivas operações aritméticas em cada nó, a começar pelas folhas.

Resumidamente, 14 é a semântica da sintaxe 2 + (3 * 4) e é calculada usando a representação intermédia ('+', 2, ('*', 3, 4)).

Em cada nó o conteúdo (daqui em diante representado por op) define a operação e os descendentes vão definir os valores dos argumentos (daqui em diante, args) dessa operação:

eval(('+', 2, ('*', 3, 4))) = 
    soma(eval(2), eval(('*', 3, 4))) =
    soma(2, mult(eval(3), eval(4))) =
    soma(2, mult(3, 4)) =
    soma(2, 12) =
    14

A valoração é uma função recursiva que, em cada nó (op, *args), calcula o valor dos argumentos *args e, depois, conforme o valor de op, combina esses valores no resultado correspondente.

Porém, um programa a correr define e consulta variáveis, escolhe ramos num condicional, etc.

O cálculo da valoração depende do contexto e das funções base. Um esquema incompleto da implementação segundo esses pressupostos será, por exemplo:

def eval(expr, context=None, ops=BASE_FUNCTIONS):
    if context is None:
        context = ALisPContext({})
    #
    #   expr is ATOM
    #
    context_value = context.value(expr)
    if context_value is not None:
        return context_value
    #
    #   expr is LIST
    #
    elif is_list(expr) and expr != NIL:
        #
        #   expr = (op args...)
        #
        op = head(expr)
        args = tail(expr)
        #
        # Use op and len(args) to do the right step
        # 
        if op in ops.keys():
            # BASE FUNCTIONS
        elif op == 'write' and len(args) == 1:
            # WRITE: (write MESSAGE)
        elif op == 'read' and len(args) == 0:
            # READ: (read)
        elif op == 'fn' and len(args) == 2:
            # FUNCTIONS: (fn ARGS INSTR)
        elif op == 'set' and len(args) == 2:
            # DEFINE/UPDATE VARIABLES: (set VAR VALUE) 
        elif op == 'while' and len(args) == 2:
            # CYCLES: (while GUARD INSTR)
        elif op == 'if' and len(args) == 3:
            # CONDITIONALS: (if COND TRUE_INSTR FALSE_INSTR)
        elif op == 'seq': 
            # SEQUENCE OF INSTRUCTIONS (LAST VALUE)
            # (seq *INSTR)
        elif is_list(op):
            # DEFER: (OP *ARGS)
        elif context.defines(op):
            # CONSULT VARIABLE: VAR
        else:
            # FALLBACK: (TERMINAL *REST)
    #
    #   expr is ALIEN... maybe raise error?
    #
    else:
        return expr

Funções Base

As funções base proporcionam alguma funcionalidade inicial e também uma ponte à linguagem hospedeira, o Python neste caso.

Para calcular o valor de uma função base como, por exemplo, (+ 2 3), fica op == "+", args == (2, 3) e os passos são:

Verificar se op (neste caso, +) é uma chave no dicionário das funções base (ops).
Validar a aridade (if len(args) >= arity).
Chamar recursivamente eval nos argumentos: val_args = tuple(eval(x, context, ops) for x in args[:arity]).
Devolver o valor da função associada a op quando aplicada aos valores dos argumentos: return func(*val_args).

#
# BASE FUNCTIONS
#
if op in ops.keys():
    arity, func = ops[op]
    if len(args) >= arity:
        val_args = tuple(eval(x, context, ops) for x in args[:arity])
        return func(*val_args)
    else:
        return None

Entrada/Saída

As funções de entrada e saída permitem interações com o utilizador via uma consola.

A sintaxe é:

(write MESSAGE) em que MESSAGE é um valor qualquer a ser escrito na consola.

(read) para ler um valor da consola.

A "real" interação ocorre via as funções correspondentes no Python: print para write e input para read.
No caso da saída (write):
- É admitido exatamente um argumento.
- Recursivamente, é calculado o valor desse argumento.
- O valor, que é um tuple, é enviado para a consola (print) numa sintaxe compatível com ALisP (expr_repr).
Para a entrada (read):
- Não são admitidos argumentos.
- É lido o texto da consola via input.
- Esse texto é analisado (parse).
- Recursivamente, é calculado o valor da representação obtida na análise anterior.

#
# WRITE
#
elif op == 'write' and len(args) == 1:
    value = eval(args[0], context, ops)
    print(expr_repr(value))
    return value
#
# READ
#
elif op == 'read' and len(args) == 0:
    user_input = input()
    user_prog = parse(user_input)
    value = eval(user_prog, context, ops)
    return value

Funções

As funções, em ALisP são valores como as listas, números ou textos.

A sintaxe é (fn ARGS INSTR) em que fn é a instrução, ARGS é uma lista de variáveis e INSTR é uma lista de instruções.

Depois de criada uma função pode ser guardada numa variável para uso posterior.

Por exemplo:

(
    (set succ (fn (x) (+ x 1)))
    (succ 41)
    (succ 0)
)

As funções são o único caso em que eval não é recursiva. No exemplo acima:

Em (fn (x) (+ x 1)) é definido um certo valor.
No interpretador esse valor é uma instância da classe Lambda.
Essa instância é construída com os argumentos (x,) e ('+', 'x', 1) que são as representações de "(x)" e "(+ x 1)" respetivamente.
O valor do passo anterior é guardado na variável succ.
Mais tarde, na linha seguinte, (succ 41):
- É criado um contexto local, onde x fica com o valor 41.
- Nesse contexto é calculado o valor de (+ x 1), usando eval.
Na linha (succ 0) estes passos são repetidos, mas num novo contexto local em que x tem valor 0.

A criação do valor Lambda ocorre nas seguintes linhas:

#
# FUNCTIONS
#
elif op == 'fn' and len(args) == 2:
    fn_args = args[0]
    fn_expr = args[1]
    return Lambda(fn_args, fn_expr)

O cálculo das evocações é tratado mais tarde, com as variáveis.

Copiar

Um valor é copiado para uma variável que fica registada no contexto atual. Mais tarde esse valor pode ser recuperado como o valor da variável.

A sintaxe é (set VAR VALUE) em que VAR é um identificador e VALUE uma qualquer expressão ALisP.

Por exemplo, o seguinte programa tem valor 42:

(seq
    (set bad-answer 20)
    (set almost-good-answer (* 2 bad-answer))
    (+ almost-good-answer 2)
)

No lado do interpretador as instruções set atualizam o contexto da seguinte forma:

#
# DEFINE/UPDATE VARIABLES
#
elif op == 'set' and len(args) == 2:
    var_name = uq(args[0]) # Inelegant "dequotation" :(
    var_value = eval(args[1], context, ops)
    context.set(var_name, var_value)
    return var_value

Ciclos

Um ciclo repete um bloco de instruções enquanto uma certa condição é verdadeira.

A sintaxe é (while GUARD INSTR) em que GUARD é uma condição e INSTR um bloco de instruções.

Note bem que a ALisP tem valores booleanos True e False mas a condição pode ser qualquer valor. Os valores que também valem como False são 0, 0.0 e (). Todos os restantes valores valem como True.
Por exemplo, o ciclo seguinte escreve a "tabela" dos quadrados de 0 a 10:

(
    (set i 0)
    (while (<= i 10) (
        (write (i (* i i)))
        (set i (+ i 1))
    ))
)

A implementação dos ciclos ALisP usa os ciclos do Python:

#
# CYCLES
#
elif op == 'while' and len(args) == 2:
    guard = args[0]
    statements = args[1]
    last = NIL
    while eval(guard, context, ops):
        last = eval(statements, context, ops)
    return last

Condicionais

Um condicional corre um certo bloco de instruções, ou outro, conforme uma condição é verdadeira ou falsa.

A sintaxe é (if COND TRUE_INSTR FALSE_INSTR) em que COND é uma condição e TRUE_INSTR e FALSE_INSTR são blocos de instruções.

Note bem que a sintaxe "força" três argumentos.
Por exemplo, o valor de (seq (set a 10) (if (> a 0) positivo negativo)) é positivo.

Tal como nos ciclos, os condicionais do ALisP usam os do Python:

#
# CONDITIONALS
#
elif op == 'if' and len(args) == 3:
    cond, seq_true, seq_false = args
    if eval(cond, context, ops):
        return eval(seq_true, context, ops)
    else:
        return eval(seq_false, context, ops)

Com esta implementação apenas é percorrido, e calculado o valor do bloco que corresponde ao valor da condição.

Sequências

Uma sequência de instruções corre cada uma, por ordem, e devolve o valor da última instrução. A sequência vazia, (seq) vale a lista vazia, (), designada NIL.

A sintaxe é (seq *INSTR) em que *INSTR é uma sequência de instruções.

Note bem que *INSTR não é uma lista, mas os seus elementos.
Por exemplo:
- O valor de (seq 0 1 2 3) é 3.
- O valor de (seq (0 1 2 3)) é (0 1 2 3).
- O valor de (seq (set a 40) (+ a 2)) é 42.

A implementação do valor para as sequências é:

#
# SEQUENCE OF INSTRUCTIONS (RETURNS ONLY THE LAST VALUE)
#
elif op == 'seq':
    if len(args) == 0:
        return NIL
    else:
        seq = eval(args, context, ops)
        return seq[-1]

Diferimento

Na ALisP o primeiro elemento de uma lista determina como é calculado o valor dessa lista. Pode-se evocar uma função, executar uma instrução ou apenas definir a lista dos valores.

Quando o primeiro elemento é também uma lista é preciso começar por determinar o seu valor para seguir no cálculo do valor da lista parente.

Isto é, cálculo do valor da lista parente é diferido pelo valor da lista que é o primeiro elemento.

Por exemplo, o valor de:

(1 2 3) é (1 2 3).
(+ 2 3) é 5.
(if True 42 24) é 42.
((1 2 3) 2 3) é ((1 2 3) 2 3).
((if True + *) 2 3) é 5.
((if False + *) 2 3) é 6.

Nos três últimos exemplos, 4., 5. e 6., o primeiro elemento da lista é uma lista que vai definir o modo de calcular o valor da lista parente.

No caso ((1 2 3) 2 3) o valor do primeiro elemento é (1 2 3) que não é nem uma função nem uma instrução. Tal como no exemplo 1., a lista parente tem apenas valores.

Nos exemplos 5. e 6. o valor do primeiro elemento é, respetivamente, + e *. Portanto, o valor da lista parente vai ser diferido, respetivamente, para (+ 2 3) e (* 2 3).

A implementação do cálculo diferido é:

#
# LIST OF INSTRUCTIONS (RETURNS ALL THE VALUES)
#
elif is_list(op):
    op_val = eval(op, context, ops)
    args_vals = tuple([eval(xi, context, ops) for xi in args])
    expr2 = (op_val,) + args_vals
    if op_val == op:
        return expr2
    else:
        return eval(expr2, context, ops)

O teste if op_val == op deteta se o cálculo (não) vai ser diferido.

Variáveis e Evocação de Funções

Uma variável pode referir qualquer valor ALisP, guardado no contexto atual.

Quando esse valor é um tipo básico, inteiro, double, lista, string ou booleano, basta consultar o respetivo valor, guardado no contexto.

Quando a variável refere uma função é preciso calcular o valor da função com os argumentos dados.

Por exemplo, o valor de:

(seq (set a 2) (+ a 40) é 42.
(seq ((set a +)) (a 2 40) é 42. O duplo ((set a +)) é um hack para isolar o valor de (set a +), que é +, uma operação.
(seq (set a (fn (x y) (+ x y))) (a 2 40)) é 42. Esse valor resulta de aplicar a função (fn (x y) (+ x y)) aos argumentos (2 40). O corpo e os argumentos desta função forma guardados no contexto, com nome a.

A implementação:

#
# CONSULT VARIABLE
#
elif context.defines(op):
    val = eval(op, context, ops)
    #
    #   Function evocation
    #
    if isinstance(val, Lambda):
        arity = len(val.args)
        if arity <= len(args):
            local_context = AlispContext(context)
            for i in range(arity):
                local_context.set(
                    val.args[i],
                    eval(args[i], context, ops))
            return eval(val.expr, local_context, ops)
        else:
            return None
    #
    #   Other types (number, text, list...)
    #
    else:
        expr2 = (val, ) + args
        return eval(expr2, context, ops)

Fallback

Se a "operação" não é um dos casos anteriores deve ser um terminal.

Por exemplo, (4 (+ 1 1)). Neste caso o resultado será (4 2).

A implementação:

#
# FALLBACK
#
else:
    return (op,) + eval(args, context, ops)

Exemplos

Exemplos
- Funções Recursivas
- Adivinhar o Número

Funções Recursivas

O seguinte código ALisP define uma pequena biblioteca de funções que ilustram cálculos recursivos.

(
    (set fib (fn (x) 
        (if (<= x 1) 
            1 
            (+ 
                (fib (- x 1))
                (fib (- x 2)) )
        )
    ))

    (set fact (fn (n)
        (if (<= n 1)
            1
            (*  
                n 
                (fact (- n 1))
            )
        )
    ))
)

Guarde este código em, por exemplo, recursivas.lisp e experimente:

alisp.py -l recursivas.lisp -e "(fact 100)" e deve obter imediatamente o resultado, que é um número com 246 dígitos ;)
alisp.py -l recursivas.lisp -e "(fib 20)" demora um tempo considerável (alguns segundos) e o resultado é 10946.
Exercício. A implementação de fib é muito pouco eficiente (porque o mesmo cálculo é feito duas vezes em cada passo!). Modifique-a (substituindo a recursão por um ciclo) de forma a ter um desempenho melhor. Deve conseguir calcular rapidamente (fib 10000), que tem 2090 dígitos. Já fib 100000) demora alguns segundos e é um número com 20899 dígitos :D

Adivinhar o Número

O jogo Adivinha o número é um problema simples que permite testar várias caraterísticas de uma linguagem de programação.

O programa define um número secreto, entre 0 e 100 e o jogador tem de adivinhar esse segredo.

O programa pede um palpite ao jogador.

Se a resposta do jogador está certa, o jogo termina. O programa dá os parabéns e diz quantas tentativas foram necessárias.

Caso contrário, o programa responde maior ou menor conforme o segredo é maior ou menor que o palpite e volta a pedir um palpite.

Uma implementação do Adivinha o Número em ALisP:

(seq
    (set greet (fn (name)
        (Hello name . Welcome to the Guess-the-Number game.)
    ))

    (set ord (fn (n)
        (if (== 1 n)
            first
            (if (== 2 n)
                second
                (if (== 3 n)
                    third
                    (n -th)
                )
            )
        )
    ))

    (set main (fn ()
        (write (What is your name?))
        (set name (read))
        (write (greet name))
        (set my-secret 42)
        (set answer 50)
        (set count 0)
        (while (!= answer my-secret) (
            (set count (+ count 1))
            (write (Guess the secret number [(ord count) tentative]))
            (set answer (read))
            (write
                (if (== answer my-secret)
                    (Very well name . You found that the secret is ** my-secret ** using only count guesses.)
                    (Not yet, name . The secret is **
                        (if (< my-secret answer)
                            smaller
                            greater
                        )
                        ** than answer . Try again.
                    )
                )
            )
        ))
    ))

    (main)
    BYE
)

Conclusão

Definiu-se uma linguagem de programação, a ALisP, com sintaxe e a semântica largamente inspiradas/copiadas do Lisp, e implementou-se um interpretador:

A sintaxe é definida por uma gramática LL(1).

O processo da análise sintática produz uma representação intermédia do programa.

A ALisP tem valores inteiros, double, string, booleanos, listas e funções anónimas.

Os valores podem ser guardados em variáveis e consultados posteriormente.

As instruções proporcionam ciclos e condicionais.

A interação com o utilizador é feita através da consola.

O interpretador pode ser inicializado com um conjunto de funções base adequadas a tarefas específicas de um determinado domínio.

Além da interpretação de expressões/instruções/programas são convenientes algumas utilidades, proporcionadas pelo programa alisp.py:

Uma forma de calcular diretamente o valor de uma expressão: alisp.py -e "(+ 40 2)".
Uma forma de correr um programa definido num ficheiro: alisp.py -l guess-the-number.lisp.
Uma forma de usar interativamente a linguagem: alisp.py --repl.
Estas formas pode ser combinadas, de forma a que, por exemplo, uma biblioteca de funções possa ser carregada para calcular uma expressão e/ou usada numa sessão interativa:

alisp.py -l functions.list -e "(set answer (dobro 21))" --repl

Exercícios

Em Construção

Exercício 01

Para cada um dos pares palavra/gramática seguintes, obtenha a estrutura simplificada da palavra na forma de uma árvore apenas com terminais nos nós.

Emparelhe E → E + T | E - T | T ; T → T × F | T ÷ F | F ; F → N | ( E ), em que N representa qualquer número inteiro, com:
1. 2, (2), 2 + 3, 2 × 3, (2 + 3).
2. 2 + (3 × 4), 2 + 3 × 4 e (2 + 3) × 4.
3. 2 + (3 + 4), 2 + 3 + 4 e (2 + 3) + 4.
4. (2 + 3) × (3 + 4), 2 + (3 × 3) + 4, 2 + 3 × 3 + 4.
5. (2 × 3) + (3 × 4), 2 × (3 + 3) × 4, 2 × 3 + 3 × 4.
sequências; lisp;

Exercício 02

Os nós de árvores podem ser representadas por listas heterogéneas (suportadas diretamente, por exemplo, em Python) em que o primeiro elemento é o conteúdo do nó e os seguintes elementos são os descendentes. Por convenção, as folhas representam-se apenas pelo conteúdo (isto é, pelo valor 42 em vez da lista [42]). Implemente:

degree(a) o número de descendentes de a.
size(a) o número de nós em a.
tree_degree(a) o maior grau dos nós em a.
is_leaf(a) se a não tem descendentes.
is_inner(a) se a tem descendente.
is_parent(a, b) se a é ascendente direto de b.
is_neighbor(a, b) se a é ascendente direto de b ou vice-versa.
is_antecessor(a, b) se a é ascendente (direto, ou não) de b.
is_descendant(a, b) se a é descendente (direto, ou não) de a.
level(a, b): se b descende de a, o número de arestas do caminho que liga a a b; caso contrário, None.
width(a, n) o número de descendentes de a no nível n.
breadth(a) o número de folhas de a.
pesquisas; inserir; remover; podar; menor ascendente comum de dois nós;

Exercício 03

Revisitar exercícios de Python?
Funções anónimas (???)
- Aplicações: map, filter, reduce

Exercício 04

Lisp (sbcl)

Exercício 05

E → T E₁
E₁ → + T E₁ | - T E₁ | λ
T → F T₁
T₁ → * F T₁ | / F T₁ | λ
F → ( E ) | N
N → D N₁
N₁ → λ | D N₁
D → 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Verifique que a gramática acima é LL(1) e implemente uma calculadora na linha de comandos para efetuar contas simples como 2 + (3 * 4).

Exercício 06

Melhorar ALisP:
- Incluir um gerador de números aleatórios nas funções base.
- Corrigir atom_value de forma a prever o tipo do valor, em vez de levantar exceções.
- Tratar adequadamente as string, delimitadas por ".
- Suportar quote, de forma a suspender a valoração de uma expressão.
- Mudar ALisP.value de forma a que True e False sejam sempre booleanos (não é o caso agora!)
Extensões ALisP
- (range start end) (fechado-aberto).
- (for var list instr)
- (native "Python expr") como?
- (pair key val), (update key val map), (get key map), (keys map)
- (fn-map fn list), (filter pred list),