Redução-β em Prolog

Luiz Arthur Pagani (UFPR)∗

Resumo

Apresenta-se aqui uma nova implementação em Prolog para a operação de

redução-β, parte do cálculo-λ importante para a semântica composicional, e que não

apresenta o mesmo defeito das implementações de Pereira & Shieber e de Blackburn

& Bos (em ambas, as variáveis ligadas pelo operador-λ acabam instanciadas com

constantes, o que inviabiliza a manutenção do histórico derivacional das reduções).

1 Introdução

O cálculo-λ é uma ferramenta indispensável para a construção da representação compo-sicional da interpretação semântica de uma expressão linguística desde, pelo menos, oadvento da Semântica de Montague (como podemos perceber facilmente em manuais desemântica formal, como [7, ps. 98�110], [3, p. 112�149], [8, p. 34�39], [5, ps. 391�429]; etambém em manuais de linguística computacional, como [6, ps. 64�65] e [1, ps. 265�267]).

Neste contexto, o cálculo-λ é usado, por exemplo, para identi�car uma fórmula (umtermo-λ) que represente o signi�cado do item lexical todo, em todo menino corre, de formaque ela colabore composicionalmente na representação do signi�cado daquela sentença;além disso, é possível uni�car a representação do signi�cado dos quanti�cadores com ados nomes próprios (chamada de quanti�cação generalizada, onde a denotação de ambasas fórmulas correspondem a conjuntos de conjuntos).

Considerando que o signi�cado de todo menino corre seja representado pela clássicafórmula do cálculo de predicados ∀x.[(M x)→ (C x)], e que os signi�cados de menino ecorre também correspondam, respectivamente, aos clássicos predicadosM e C,1 podemosnos perguntar, primeiro, pela representação do signi�cado do SN e, depois, pela do Dettodo, como esquematizado na árvore abaixo.

S : ∀x.[(M x)→ (C x)]

SN :?

Det :?

todo

N :M

menino

SV : C

V : C

corre

Começando pelo SN, sabemos que o signi�cado da sentença é ∀x.[(M x) → (C x)]e que o do SV é C, podemos abstrair o segundo do primeiro, através do cálculo-λ (de

∗Email: arthur@ufpr.br, página de internet: http://www.ufpr.br/�arthur.1Esses predicados podem ser compreendidos como conjuntos de indivíduos (o de meninos, no primeiro

caso; e o dos que correm, no segundo), mas também podem ser pensados como funções que levam deindivíduos a valores de verdade (as chamadas funções características); como estas opções são equivalentes,vamos optar aqui pela representação funcional, por comodidade notacional e coerência conceitual.

1

acordo com sua apresentação, como veremos a seguir), e chegamos à conclusão de que osigni�cado do SN pode ser representado por λP.∀x.[(M x)→ (P x)]. A seguir abstraímosdeste signi�cado a parte correspondente ao N, e obtemos a fórmula λQ.λP.∀x.[(Q x) →(P x)], que representa �nalmente o signi�cado do Det todo. Assim, podemos reconstruircomposicionalmente a árvore acima da seguinte maneira:2

todo menino corre

Det : λQ.λP.∀x.[(Q x)→ (P x)] N :M V : C

SN : (λQ.λP.∀x.[(Q x)→ (P x)]M)=red.β λP.∀x.[(M x)→ (P x)]

S : (λP.∀x.[(M x)→ (P x)] C)=red.β ∀x.[(M x)→ (C x)]

O leitor perspicaz terá observado que, na derivação acima, o signi�cado do SN passaa ser uma função, que toma o signi�cado do SV como argumento (que também é umafunção, o que faz da representação do signi�cado do SN uma função de segunda ordem)para resultar no signi�cado da sentença; mas isso é o oposto do que acontece tradicional-mente na explicação de uma sentença como Pedro corre, em que o SV é que correspondeà função que toma o signi�cado do SN como argumento. No entanto, com o cálculo-λisso deixa de ser um problema: supondo que o signi�cado de Pedro seja representado porp (o indivíduo que é o próprio Pedro), basta promovê-lo para λP.(P p), para podermosusar o mesmo procedimento anterior, em que o signi�cado do SN é a função e o do SV éo argumento, como na árvore a seguir.

Pedro corre

N : p V : C

SN : λP.(P p) SV : C

S : (λP.(P p) C)=red.β (C p)

Como recurso formal, uma representação através do cálculo de predicados acrescidodo cálculo-λ é especialmente adequada para a construção composicional da interpreta-ção semântica das expressões executada computacionalmente. Portanto, o objetivo dopresente texto é o de apresentar uma implementação em Prolog deste recurso; para isso,iremos primeiro apresentar a de�nição do cálculo-λ e duas versões anteriores de imple-mentação (uma bastante super�cial e outra mais robusta), para que possamos identi�caras limitações que vamos querer superar na implementação proposta aqui.

2Mas a partir daqui vamos passar a empregar o chamado diagrama de Prawitz, bastante usado naGramática Categorial, que simpli�ca um pouco a apresentação da árvore, ainda que faça isso às custasde inverter o sentido com o qual os linguistas estão mais acostumados.

2

2 Cálculo-λ

O cálculo-λ foi �inventado� pelo matemático americano Alonzo Church, a partir de meadosdos anos 30, para tentar formalizar a Matemática através da noção de função, ao invés dateoria de conjuntos. Apesar de não ter servido aos seus propósitos originais, o cálculo-λacabou exercendo uma função importante no estudo da computabilidade, de forma a serconsiderado �a menor língua universal de programação do mundo� [11, p 1].

Seguindo a apresentação de Carpenter [4, p. 50], podemos de�nir o cálculo-λ a partirde três axiomas:3

a. ` λη.α⇒ λδ.α[η 7→ δ] (redução-α)[δ /∈ Livre(α) ∧ LivrePara(δ, η, α)]

b. ` (λη.α β)⇒ α[η 7→ β] (redução-β)[LivrePara(β, η, α)]

c. ` λη.(α η)⇒ α (redução-η)[η /∈ Livre(α)]

Como vamos nos concentrar na redução-β, não vamos comentar as outras duas redu-ções; além disso, por falta de espaço, também não apresentaremos as de�nições formaisde Livre e LivrePara (que podem ser encontradas em [4, ps. 43�44]).

O axioma da redução-β nos diz que um termo-λ com o formato λη.α (que correspondea uma função), quando toma como argumento um termo com o formato β, resulta numtermo constituído pela substituição, no termo α, de todas as ocorrências livres de η por β,contanto que β seja livre para substituir η em α (ou seja, ao substituir δ em α, nenhumavariável livre de β pode acabar sendo acidentalmente ligada).

Já apresentamos três reduções-β na seção anterior, e agora vamos observais maisdetidamente como elas foram executadas. Para aplicar a regra de redução à fórmulaque representa a composição do signi�cado do SN todo menino, podemos colocá-la numesquema que esclarece a operação:4

(λ Q︸︷︷︸ . λP.∀x.[(Q x)→ (P x)]︸ ︷︷ ︸ M︸︷︷︸ )

(λ η . α β ) ⇒ α[η 7→ β]︷ ︸︸ ︷λP.∀x.[(M x)→ (P x)]

Na linha central do esquema, temos a regra de redução-β; na linha de cima, a fórmulaa ser reduzida; e na linha de baixo, o resultado da redução. As uni�cações estão identi�-cadas com as chaves: se �zermos o η da regra valer Q (�η = Q�), �α = λP.∀x.[(Q x) →(P x)]� e �β = M �, então o resultado será �α[η 7→ β] = λP.∀x.[(M x) → (P x)]� (o Msubstitui o Q na fórmula instanciada em α).

O mesmo vale para �(λP.∀x.[(M x)→ (P x)] C)�, que é o signi�cado de todo menino

corre:

(λ P︸︷︷︸ . ∀x.[(M x)→ (P x)]︸ ︷︷ ︸ C︸︷︷︸ )

(λ η . α β ) ⇒ α[η 7→ β]︷ ︸︸ ︷∀x.[(M x)→ (C x)]

3A apresentação de Carpenter privilegia unicamente o sentido da redução, mas os axiomas tambémpodem ser �usados� na expansão (foi o que �zemos, na seção anterior, para deduzir o signi�cado de todo);quando apresentados nos dois sentidos, eles são chamados de convenção ou igualdade [9, ps. 50�51].

4Minha notação é um pouco diferente da de Carpenter: coloco a função seguida do argumento (se-parados por um espaço) entre um par de parêntesis; na de Carpenter, apenas o argumento �ca entreparêntesis.

3

E também para �(λP.(P p) C)�, que representa o signi�cado de Pedro corre:

(λ P︸︷︷︸ . (P p)︸ ︷︷ ︸ C︸︷︷︸ )

(λ η . α β ) ⇒ α[η 7→ β]︷ ︸︸ ︷(C p)

Como último exemplo, vamos apresentar a redução-β de (λP.(P p) (λQ.λx.(Q x) C)),que é uma fórmula mais complexa e apresena mais de uma alternativa de redução. Temos,na verdade, duas opções para iniciar a série de reduções;5 podemos começar reduzindo ooperador-λ que liga a variável P , como a seguir:

(λ P︸︷︷︸ . (P p)︸ ︷︷ ︸ (λQ.λx.(Q x) C)︸ ︷︷ ︸ )

(λ η . α β ) ⇒ α[η 7→ β]︷ ︸︸ ︷((λQ.(λx.(Q x) C) p)

E, depois fazer a redução da subfórmula para o operador-λ que liga a variável Q:

(λ Q︸︷︷︸ . λx.(Q x)︸ ︷︷ ︸ C︸︷︷︸ )

(λ η . α β ) ⇒ α[η 7→ β]︷ ︸︸ ︷λx.(C x)

Ou, alternativamente, podemos começar reduzindo a subfórmula na qual ocorre aligação da variável Q:

(λ Q︸︷︷︸ . λx.(Q x)︸ ︷︷ ︸ C︸︷︷︸ )

(λ η . α β ) ⇒ α[η 7→ β]︷ ︸︸ ︷λx.(C x)

Substituindo, depois a fórmula reduzida na fórmula inicial, e procedendo uma nova re-dução:

(λ P︸︷︷︸ . (P p)︸ ︷︷ ︸ λx.(C x)︸ ︷︷ ︸ )

(λ η . α β ) ⇒ α[η 7→ β]︷ ︸︸ ︷(λx.(C x) p)

De qualquer maneira, no �nal, obtemos a mesma fórmula, que precisa ainda passarpela última redução-β para chegarmos à forma equivalente mais simples para a fórmulainicial (λP.(P p) (λQ.λx.(Q x) C)):

(λ x︸︷︷︸ . (C x)︸ ︷︷ ︸ p︸︷︷︸ )

(λ η . α β ) ⇒ α[η 7→ β]︷ ︸︸ ︷(C p)

5Efetivemente, usando o cálculo-λ integralmente, teríamos mais alternativas, já que a subfórmulaλQ.(Q x) pode sofrer uma redução-η; como aqui estamos nos concentrando na redução-β, não explora-remos esta possibilidade.

4

O que é importante observar, antes de passarmos às implementações, é que a redução-β só se aplica a um termo-λ com a forma (λη.α β) � onde η é uma variável, e α e βsão outros termos-λ.6 Mas, principalmente, aquilo que o operador-λ liga precisa sernecessariamente uma variável.7

3 Implementações anteriores

Passemos, então, às duas implementações encontradas.

3.1 Pereira & Shieber

No livro de Pereira e Shieber [10, p. 96], podemos encontrar o que provavelmente seja aprimeira tentativa de implementar a redução-β em Prolog, de�nida numa única linha:

reduce(Arg^Expr, Arg, Expr).

Todo o trabalho de redução é executado pela uni�cação do argumento (Arg) com avariável ligada pelo operador-λ (que aqui é representado pelo acento circun�exo (^) emposição in�xa); o resultado decorre da uni�cação com o escopo do operador (Expr).

Assim, para executar, por exemplo, a redução de �(λP.(Pp) C)� é preciso convertera fórmula para o formato escolhido pelos autores. Além do operador-λ in�xo (^), aaplicação funcional é representada pelo sinal @; assim, a parte funcional da fórmula éescrita em Prolog como P^P@p.8 E a redução pode ser invocada da seguinte maneira:

?- reduce(P^P@p, c, Result).

P = c,

Result = c@p.

Há fundamentalmente dois problemas nesta implementação. O primeiro é que elanão dá conta da complexidade estrutural de todas as fórmulas que poderíamos precisarreduzir; como a redução não é difundida para as subfórmulas da fórmula a ser reduzida,reduções em algumas dessas subfórmulas não seriam processadas. O segundo problema éque a uni�cação do argumento com a variável ligada pelo operador-λ acaba instanciandoesta variável com uma constante (P = c); assim, caso precisássemos continuar usando afórmula �λP.(P p)� (P^P@c) � para manter um histórico derivacional � ela já estariacorrespondendo a �λc.(c p)� (c^c@p); ou seja, teríamos uma constante onde deveríamoster obrigatoriamente uma variável.

6Na notação que estamos usando, a dica para identi�car uma redução-β é achar um parêntesis abrindoseguido do operador-λ: � . . . (λ. . . �.

7Não estamos dando atenção às restrições sobre ligação das variáveis porque no uso que fazemos daredução-β todas as variáveis introduzidas em qualquer derivação precisam ser novas; isso garante quenão haja ligações indevidas (as únicas ligações são as que ocorrem com operadores de ligação inseridoslexicalmente).

8Sem os parêntesis, a representação presupõe uma precedência maior do operador funcional em relaçãoao operador-λ.

5

3.2 Blackburn & Bos

A outra implementação está no livro de Blackburn e Bos [2, ps. 77�78], e pode ser obtidadiretamente da internet.9 Como podemos observar na listagem abaixo, ao lidar com aestrutura das fórmulas a serem reduzidas, esta implementação é capaz de fazer as reduçõesinternas.

betaConvert(X,Y,[]):-

var(X), !,

Y=X.

betaConvert(Expression,Result,Stack):-

nonvar(Expression),

Expression = app(Functor,Argument),

betaConvert(Functor,Result,[Argument|Stack]), !.

betaConvert(Expression,Result,[X|Stack]):-

nonvar(Expression),

Expression = lam(X,Formula),

betaConvert(Formula,Result,Stack), !.

betaConvert(Formula,Result,[]):-

nonvar(Formula), !,

Formula =.. [Functor|Formulas],

betaConvertList(Formulas,ResultFormulas),

Result =.. [Functor|ResultFormulas].

No entanto, a seguir mostramos uma seção de redução de (λP.(P mia) λx.(snort x))(que, na notação em Prolog dos autores, em que a aplicação funcional é representada pelopredicado app/2 e o operador-λ pelo predicado lam/2) é escrita como �app(lam(A, app(A,

mia)), lam(B, snort(B)))�.

?- betaConvert(app(lam(A, app(A, mia)), lam(B, snort(B))), Result, []).

A = lam(mia, snort(mia)),

B = mia,

Result = snort(mia).

Como se nota, apesar de estruturalmente mais completo, este programa sofre dooutro problema que o anterior também sofria: a uni�cação B = mia causa a uni�caçãoA = lam(mia, snort(mia)), tornando a fórmula reduzida inadequada para o registro dohistórico derivacional, colocando uma constante onde só poderia haver uma variável.

4 Nova implementação

Avaliando os resultados equivalentes em ambas as implementações anteriores, observa-se que as variáveis do Prolog são usadas para representar diretamente as variáveis dalíngua de representação da interpretação semântica. Desse modo, a nova proposta queserá apresentada a seguir trata as variáveis da língua representacional como constantesdo Prolog; apesar de poder soar inicialmente como uma contradição, na verdade, esta

9O endereço é http://homepages.inf.ed.ac.uk/jbos/comsem/download/bb1.tar.gz. A versãoapresentada aqui foi simpli�cada em relação ao arquivo disponibilizado na internet pelos autores,assemelhando-se mais à primeira versão comentada no livro.

6

opção segue a distinção entre variável e metavariável, tratando as variáveis como coisas aserem descritas, e portanto como coisas a serem referidas através de constantes, �candoas variáveis do Prolog com a função de representar as metavariáveis.

% Definição dos operadores

:- op(500, yfx, @). % aplicação funcional

:- op(550, xfx, /\). % conjunção

:- op(550, xfx, =>). % implicação

:- op(600, xfy, ^). % operador-lambda

% Lista de conectivos proposicionais

con_prop(/\).

con_prop(=>).

% Lista de quantificadores

quant(algum).

quant(todo).

% reduz_lista(Lista, Reduzido)

% ******************************************

% * Reduzido é o resultado da redução-beta *

% * recorrente do primeiro Termo da Lista *

% ******************************************

reduz_lista(Lista, Reduzido) :-

Lista = [Termo|_],

reduz_termo(Termo, Resultado),

reduz_lista([Resultado|Lista], Reduzido),

!.

reduz_lista(Resultado, Resultado).

% reduz_termo(Termo1, Termo2)

% **************************************************

% * Termo2 é o resultado da redução-beta do Termo1 *

% **************************************************

% Aplicação

reduz_termo((Var^Termo)@Arg, Resultado) :-

substitui(Termo, Var, Arg, Resultado).

reduz_termo(Termo1@Termo2, Termo1@Resultado) :-

reduz_termo(Termo2, Resultado).

reduz_termo(Termo1@Termo2, Resultado@Termo2) :-

reduz_termo(Termo1, Resultado).

% Abstração

reduz_termo(Var^Termo, Var^Resultado) :-

reduz_termo(Termo, Resultado).

% Conectivos proposicionais

reduz_termo(Termo, Resultado) :-

Termo =.. [Con, Termo1, Termo2],

con_prop(Con),

reduz_termo(Termo2, Parcial),

7

Resultado =.. [Con, Termo1, Parcial].

reduz_termo(Termo, Resultado) :-

Termo =.. [Con, Termo1, Termo2],

con_prop(Con),

reduz_termo(Termo1, Parcial),

Resultado =.. [Con, Parcial, Termo2].

% Quantificadores

reduz_termo(Termo, Resultado) :-

Termo =.. [Quant, Var, SubTermo],

quant(Quant),

reduz_termo(SubTermo, Parcial),

Resultado =.. [Quant, Var, Parcial].

% substitui(Termo1, Var, Termo2, Termo3)

% ***************************************************************

% * Termo3 é o resultado de substituir Var por Termo2 no Termo1 *

% ***************************************************************

% Variável

substitui(x(M), x(N), Termo2, Termo3) :-

( x(M) \= x(N)

-> Termo3 = x(M)

; Termo3 = Termo2

).

% Constante

substitui(Termo3, _, _, Termo3) :-

atom(Termo3).

% Aplicação

substitui(Termo1a@Termo1b, Var, Termo2, Termo3a@Termo3b) :-

substitui(Termo1a, Var, Termo2, Termo3a),

substitui(Termo1b, Var, Termo2, Termo3b).

% Abstração

substitui(Var1^Termo1, Var, Termo2, Termo3) :-

( Var1 = Var

-> Termo3 = Var1^Termo1

; substitui(Termo1, Var, Termo2, Resultado),

Termo3 = Var1^Resultado

).

% Conectivos proposicionais

substitui(Termo1, Var, Termo2, Termo3) :-

Termo1 =.. [Con, Termo1a, Termo1b],

con_prop(Con),

substitui(Termo1a, Var, Termo2, Termo3a),

substitui(Termo1b, Var, Termo2, Termo3b),

Termo3 =.. [Con, Termo3a, Termo3b].

% Quantificadores

substitui(Termo1, Var, Termo2, Termo3) :-

Termo1 =.. [Quant, Var1, SubTermo1],

quant(Quant),

8

( Var1 = Var

-> Termo3 =.. [Quant, Var1, SubTermo1]

; substitui(SubTermo1, Var, Termo2, Resultado),

Termo3 =.. [Quant, Var1, Resultado]

).

Abaixo podemos observar um exemplo de uso da nova implementação. Para facilitar aapresentação, incluí no programa o predicado reduz_lista/2, que toma uma lista comoentrada (que deve ser instanciada com uma lista que contenha apenas a fórmula a serreduzida) e devolve como saída uma lista com a sequência de reduções-β executadas (emordem inversa, devido ao empilhamento da lista no Prolog).

?- reduz_lista([(x(0)^x(0)@p)@(x(1)^c@x(1))], Resultado).

Resultado = [c@p, (x(1)^c@x(1))@p, (x(0)^x(0)@p)@ (x(1)^c@x(1))].

Neste exemplo, foi pedido que o programa reduzisse a fórmula �(λP.(P p) λx.(C x))�(representada por (x(0)^x(0)@p)@(x(1)^c@x(1)), onde x(0) está para P e x(1) parax). Como se pode constatar, o programa produz uma lista com c@p na primeira posi-ção (que corresponde a �(C p)�, que é a forma normal da fórmula inicial de entrada),(x(1)^c@x(1))@p na posição intermediária (que corresponde à fórmula �(λx.(C x) p))�,e a própria fórmula de entrada na última posição. Assim, pudemos manter o históricodas reduções, sem instanciar variáveis com constantes nas expressões com o operador-λ.

5 Conclusões

Evidentemente, é possível que haja uma possibilidade de remendar as implementaçõesanteriores, de forma a evitar a propagação das instanciações indevidas. No entanto, asolução proposta aqui parece mais �el à sintaxe do cálculo-λ e a uma certa �loso�a daprogramação em Prolog (e mesmo do cálculo de predicados), que determina que tratemosas entidades manipuladas como constantes e reservemos as variáveis para as asserçõesquanti�cadas.

A presente proposta também inclui um exemplo da manipulação da estrutura docálculo de predicados, de�ndo-se operadores para representar os conectivos proposicionaise usando predicados para representar os quanti�cadores. Aqui exempli�camos apenas ade�nição da conjunção e da implicação, mas os outros conectivos proposicionais poderiamser facilmente introduzidos na implementação pelos mesmos moldes.10

Finalmente, convém observar que o que foi apresentado aqui é apenas uma pequenaparte da implementação do cálculo-λ. Não apenas não implementamos os outros doisaxiomas (diferentemente de [2, ps. 78�82], no qual se apresenta uma de�nição para aredução-α), como a implementação só foi concebida para o sentido da redução, e nãopara o da expansão (assim como a de Blackburn & Bos). No entanto, nas aplicações emque temos empregado a presente implementação (basicamente em assistentes de análise

10A negação, por ser um conectivo unário (ao contrário dos outros, que são binários), exigiria umtratamento especial. De qualquer forma, bastaria incluir uma cláusula especí�ca na de�nição dos predi-cados reduz_termo/2 e substitui/2, nos mesmos termos da cláusula dos binários, mas apenas para umsubtermo; ou, alternativamente, designar um predicado que percorresse a lista de subtermos reunidospelo conectivo proposicional (a implementação de Blackburn & Bos faz exatamente isso na sua últimacláusula, ainda que de forma precária: a sintaxe dos conectivos e dos quanti�cadores não é explicitada).

9

e analisadores gramaticais para Gramáticas Categoriais), não sentimos a necessidade deempregar nenhum dos outros dois axiomas (a ligação indevida de variáveis é evitada,como comentamos na nota 7, através da inserção de variáveis sempre novas; e ainda nãoencontramos motivação linguística para o emprego da conversão-η).

Referências

[1] James Allen. Natural Language Understanding. Benjamin/Cummings, California,second edition, 1995.

[2] Patrick Blackburn and Johan Bos. Representation and Inference for Natural Lan-

guage � A First Course in Computational Semantics. CSLI, Stanford, CA, 2005.

[3] Ronnie Cann. Formal Semantics � An Introduction. Cambridge University Press,Cambridge, 1993.

[4] Bob Carpenter. Type-Logical Semantics. The MIT Press, Cambridge, MA, 1997.

[5] Gennaro Chierchia and Sally McConnell-Ginet. Meaning and Grammar � An Intro-

duction to Semantics. The MIT Press, Cambridge, MA, second edition, 2000.

[6] Michael A. Covington. Natural Language Processing for Prolog Programmers. Pren-tice Hall, Englewood Cli�s, 1994.

[7] David R. Dowty, Robert E. Wall, and Stanley Peters. Introduction to Montague

Semantics. Reidel, Dordrecht, 1981.

[8] Irene Heim and Angelika Kratzer. Semantics in Generative Grammar. Wiley-Blackwell, Oxford, 1998.

[9] Glyn V. Morrill. Type Logical Grammar. Kluwer, Dordrecht, 1994.

[10] Fernando C. N. Pereira and Stuart M. Shieber. Prolog and Natural Language Analy-

sis. CSLI, Stanford, 1987.

[11] Raúl Rojas. A tutorial introduction to the lambda calculus. [A partir dehttp://www.utdallas.edu/�gupta/courses/apl/lambda.pdf, acessado em 04.09.2012],1998.

10