Linguagens Lógicas & Prolog - PUC-Rio

Linguagens Lógicas 

Linguagens de Programacão I 

mleal@inf.puc-rio.br 1 

Introdução 

Em LPs imperativas um programa é composto por 

uma sequência de comandos que representam as 

atividades computacionais que serão executadas. 

O programador deve portanto especificar claramente 

como realizar o processamento desejado, ou seja, 

como é o algoritmo. 

Em LPs lógicas um programa consiste na definição 

de relações lógicas que devem ser satisfeitas pela 

solução procurada. 

A busca por uma solução acontece automaticamente 

através de regras de inferência. 


mleal@inf.puc-rio.br 2

Introdução 

Programar em uma LP lógica consiste em: 

Declarar fatos primitivos sobre um domínio; 

Definir regras que expressam relações entre os 

fatos de um domínio; 

Fazer perguntas sobre um domínio. 

O processo de dedução através do qual 

encontram-se 

respostas às perguntas é 

executado automaticamente pelo sistema. 



1. Aves botam ovos. 

Exemplo 

2. Mamíferos não botam ovos. 

3. Baleias são mamíferos. 

4. Baleias botam ovos? 

Não. 

5. Quem bota ovos? 

Aves. 



Fatos 

Uma forma de declarar um fato como “uma 

baleia é um 

mamífero” ” é: 

mamifero (baleia). 

Para representar o fato “Bruno 

gosta de Ana” podemos 

escrever: 

gostar(bruno, ana) 

Repare que este fato é diferente de “Ana“ 

gosta de Bruno”: 

gostar(ana, bruno) 

Nas expressões acima gostar é o predicado do fato, 

representando uma relação entre os argumentos. 



Fatos 

Outros exemplos de fatos 

campeao(flamengo). 

vender(marcelo,carro,carlos). 

chuva. 

Esta sintaxe não corresponde a invocação de 

uma função!!! 



Regras 

A declaração de regras (axiomas) em LPs lógicas 

segue um padrão conhecido como cláusulas de 

Horn: 

HA 1 ,A 2 ,..., A n 

se todos os A i são verdadeiros, então H é verdadeiro. 

Na expressão acima, H é denominado a cabeça da 

cláusula e A 1 ,A 2 ,..., A n é o seu corpo. 

Através de regras pode-se estabelecer relações 

entre fatos. 



Resolução 

Para descobrir novas relações uma LP lógica utiliza 

um processo conhecido como resolução. 

O corpo de uma cláusula é equivalente a sua 

cabeça, e ambos podem ser substituídos livremente 

em outras cláusulas para formar novas regras. 

CA,B 

DC 

 

DA,B 

Através do processo de resolução uma LP lógica é 

capaz de provar a validade de proposições. 



Banco de Dados 

O conjunto de fatos e relações contidos 

em um programa lógico é denominado 

banco de dados, e representa o 

conhecimento sobre um ou mais 

domínios. 

O objetivo de um programa lógico é 

inferir e validar novos fatos ou relações 

a partir do banco de dados. 



Prolog 

Foi desenvolvida no início da década de 70 

para ser usada na prova de teoremas. 

Ainda hoje é a mais popular e principal LP 

lógica. 

É bastante utilizada em sistemas 

especialistas. 

Em Prolog um programa é composto por 

fatos e regras. 



Fatos em Prolog 

Fatos em Prolog são representados 

através de átomos ou estruturas. 

Átomos são strings que começam 

sempre com letra minúscula: 

esta_chovendo. 

dinheiro. 

joao. 




Estruturas são átomos seguidos de uma lista 

de argumentos entre parânteses: 

pred (arg1, arg2, ..., argN). 

onde: 

pred - nome de um predicado 

arg1, ... argN - argumentos 

N - número de argumentos (aridade) 

. - final sintático de qualquer cláusula Prolog 




Os argumentos de uma estrutura podem ser 

átomos, estruturas, variáveis e números. 

Exemplos: 

caro(diamente). 

amigo(joana, patricia). 

arvore_bin(valor1, arvore_bin(valor2, valor3)). 

quantidade(24). 

Estruturas representam relações entre os 

argumentos, ou seus predicados. 



Variáveis 

Em LPs imperativas variáveis são instanciadas 

através de operações explícitas de atribuição. 

Em LPs lógicas variáveis geralmente são 

instanciadas implicitamente pelo sistema durante o 

processo de resolução. 

São usadas basicamente para extrair informações do 

banco de dados, e para expressar relações entre 

fatos. 

Variáveis em Prolog são representadas por strings 

que começam com uma letra maiúscula. 



Exemplos 

offroad(X):- carro(X),tracao4x4(X), 

suspensaoReforcada(X). 

frio(groelandia). 

?-frio(X). 

x=groelandia. 



Questões 

Questões são representados por fatos 

precedidos por -?. 

?-gostar(bruno, ana). 

Informalmente: : Bruno gosta de Ana? 

Formalmente: : É possível provar a partir dos fatos 

conhecidos pelo programa que a relação 

gostar(bruno, ana) é verdadeira? 



Exemplos 

animal (cachorro) 

animal (gato) 

?-animal(cachorro). 

yes 

?-animal(X) 

X = cachorro; 

X = gato; 

yes 



Unificação 

Para tentar provar um fato Prolog precisa 

estabelecer a equivalência entre fatos. 

Dois fatos equivalentes são ditos unificáveis. 

Dois átomos são unificáveis apenas se são 

idênticos. 

Duas estruturas são unificáveis se o seu 

predicado é idêntico, e se seus argumentos 

são unificáveis . 



Unificação 

Uma variável é unificável a qualquer coisa. 

Durante o processo de resolução, uma 

variável é instanciada com um valor que 

permite a sua unificação com um símbolo 

correspondente de um outro fato. 

O símbolo = em prolog representa unificação. 



Exemplos 

fruta(manga). 

?-fruta(X). 

X = manga 

X foi unificada com “manga” 

gostar(bruno,ana). 

?-gostar(bruno,X). 

X = ana 

X foi unificada com “ana” 

?-X=sol. 

X=sol X foi unificada com “sol” 

?-sol=sol. 

yes “sol” foi unificado com “sol” 



Regras em Prolog 

Regras são representadas como cláusulas 

de Horn seguindo a sintaxe: 

pred(X1,...,Xn):- 

pred1(X1,...,Xn),...,predn(X1,...,Xn). 

se os predicados 1 a n são verdadeiros para 

as variáveis Xi, então o predicado pred é 

verdadeiro para as variáveis Xi. 

A variável representa portanto o símbolo para 

o qual a regra é verdadeira. 



Exemplos 

pai(joao,joaquim). 

pai(joaquim,manuel). 

avo(X,Y):-pai(Z,Y),pai(X,Z). 

?-avo(joao,Z). 

Z=manuel 

?-avo(joao,manuel). 

yes. 



Conjunções 

Conjunções permitem a especificação de questões 

com múltiplas condições que devem ser satisfeitas 

simultaneamente. 

Conjunções são representadas por uma vígula ( , ). 

Exemplo: 

?- localizacao(X,cozinha), comida(X), gostoso(X). 

Existe alguma comida gostosa na cozinha? 



Disjunções 

Disjunções permitem a especificação de questões 

com múltiplas condições na qual ao menos uma 

delas deve ser satisfeita. 

Disjunções são representadas por um ponto-e- 

vírgula ( ; ). 

Exemplos: 

?-amigos(X,Y); parentes(X,Y). 

inverno(X):- nevando(X); gelado(X). 

É inverno se está nevando ou está gelado. 



Fluxo de Controle 

Prolog possui um fluxo de controle implícito através 

do qual busca responder uma questão. 

Este fluxo é determinístico, ou seja segue sempre 

uma mesma ordem: 

O banco de dados é percorrido sequencialmente na ordem 

em que os fatos\regras 

foram declarados. 

Para cada predicado correto encontrado, os argumentos são 

testados em ordem. 

Para cada regra, , as condições são testadas sempre da 

esquerda para a direita. 



Exemplo 

tropical(caribe). (1) 

tropical(havai). 

praia(havai). 

praia(caribe). (2) 

bonito(havai). 

bonito(caribe). (3) 

paraiso_tropical(X):-tropical(X),praia(X), 

tropical(X),praia(X), 

bonito(X). 

?-paraiso_tropical(X). 

X=caribe; 

X is caribe 

true 

X is caribe 

true 

X is caribe 

tropical praia bonito 

true 



Fluxo de Controle 

Variáveis são instanciadas implicitamente com 

valores que permitem a unificação da estrutura. 

Assim que uma associação válida for encontrada, os 

valores com os quais as variáveis foram instanciadas 

são impressos. 

Apenas a primeira associação válida é impressa. 

Para que todas as associações válidas possam ser 

encontradas basta digitar um ; após cada resultado 

apresentado por Prolog. 



Fluxo de Controle Implícito 

Para provar questões mais complexas Prolog pode 

ser obrigado a testar várias vezes a mesma 

condicão, instanciando uma mesma variável com 

diferentes valores. 

A sequência com que os fatos e regras são testados 

portanto não é necessariamente linear, e segue um 

caminho semelhante a uma árvore. 

O processo de retornar para uma condicão e testá-la 

novamente é denominado backtracking. 



Exemplos 

surf(vitor). 

surf(renan). 

surf(teco). 

skate(vitor). 

skate(teco). 

moto(renan). 

moto(teco). 

radical(X):-surf(X),skate(X),moto(X). 

?-radical(X). 

teco. 



Exemplo 

radical(X):-surf(X),skate(X),moto(X). 

radical(X) 

surf(X) skate(X) moto(X) 

X is vitor 

X is renan X is teco X is vitor 

X is renan 

X is teco 

X is vitor 

x is teco 

surftrue 

skatefalse skatetrue moto false moto true 



Modificando o Fluxo de Execução 

Prolog oferece dois comandos que permitem alterar 

o fluxo natural de execução. 

cut: ! 

fail 

Usado para impedir o backtracking. 

Ao ser ultrapassada, não permite retorno. 

Faz com que a busca sempre falhe, provocando 

backtracking. 

Usado em combinação com ! para gerar um not. 



Exemplos 

not(P):- 

call(P),!,fail;true. 

gosta(maria,X):- cobra(X),! , fail; animal(X). 

statement:- condition, !, then_part; else_part. 

filosofo(X) :-: 

intelectual(X),grego(X). 

intelectual(platao). 

intelectual(socrates). 

grego(platao). 

grego(socrates). 

listar_filosofos:- 

write(‘Filosofos: ‘), nl, 

filosofo(X),write(X),nl, 

fail. 



Igualdade 

Em Prolog existem quatro operadores que 

representam igualdade: 

1. X == Y – Relação de identidade. É verdadeiro apenas se 

X e Y são idênticos (representam a mesma variável ou o 

mesmo símbolo). 

2. X = Y - Unificação. É verdadeiro se X é unificável com Y. 

3. X =:= Y – Significa “calcule X, calcule Y e teste sua 

igualdade”. X e Y devem ser expressões aritméticas. 

4. X is Y - Significa ``calcule Y e unifique X com Y''. Y deve 

ser uma expressão aritmética. 



Aritmética 

O operador is é o mais utilizado em operações 

aritméticas, e força a instanciação de variáveis. 

Exemplos 

?- X is 1+2 

X = 3 

?-1+2 is 4-14 

no 

fib(0,1). 

fib(1,1). 

fib(X,R):- A is X-1, X 

B is X-2, X 

fib(A,R1), fib(B,R2), 

R is R1+R2. 



Listas 

Prolog suporta uma notação especial para representar listas. 

Uma lista genérica tem a seguinte sintaxe: 

[elem1, elem2,..., elemN] 

Para manipular uma lista pode-se utilizar a notação [H|T] onde 

H representa o primeiro elemento da lista e T os demais 

elementos. 

member(X, [X|T]). 

member(X, [H|T]):- member (X, T). 

last(X,[X]). 

last(X, [H|T]):- last (X, T). 



Predicados da Linguagem 

asserta(X) 

- adiciona a cláusula X no início do banco 

de dados. 

assertz(X) 

- adiciona a cláusula X no final do banco 

de dados. 

retract(X) - remove a cláusula X do banco de dados. 

call(X) – tenta satisfazer a cláusula X. 



I/O 

see(arq 

arq) – redireciona o input para o arquivo arq. 

seeing(arq 

arq) – unifica arq com o input corrente. 

seen - fecha o input corrente. 

tell(arq 

arq) – redireciona o output para o arquivo arq. 

telling(arq 

arq) – unifica arq com o output corrente. 

told - fecha o output corrente. 



I/O 

read(Term) – lê o próximo termo (string) do arquivo corrente. 

Retorna ‘end_of_file’ se eof. 

write(Term) – imprime Term no output corrente. 

get0(N) – lê o próximo caracter do input corrente e unifica o seu 

código ASCII com N. Retorna –11 se eof. 

get(N) – lê o próximo caracter não nulo do input corrente e 

unifica o seu código ASCII com N. Retorna –11 se eof. 

put(N) – imprime o caracter correspondente ao ASCII N no 

output corrente. 

nl – imprime um newline. 

tab(N) – imprime N espaços. 



Gramáticas de Cláusulas Definidas 

Gramáticas de Cláusulas Definidas (definite clause 

grammars - DCGs) estendem gramáticas livres de 

contexto permitindo o uso de argumentos ou 

procedimentos embutidos nas produções (cláusulas). 

Prolog suporta diretamente a definição de DCGs 

através de uma sintaxe especial. 

Através deste mecanismo é fácil construir parsers 

para qualquer gramática livre de contexto. 



Exemplo 

Considera a seguinte gramática: 

::= . 

::= 

::= | 

::= a | o 

::= menino | menina | gato | cachorro 

::= viu | mordeu | dormiu | chamou 



Exemplo 

A partir da frase “o cachorro mordeu o gato.” 

podemos criar o seguinte grafo: 

o cachorro mordeu o gato . 

1 2 3 4 5 6 7 

Para respresentar um sintagma nominal podemos 

usar a regra: 

sintagmaNominal(K,L) :-: 

artigo(K,M), 

substantivo(M,L). 

 

sintagmaNominal(1,3) :-: 

artigo(1,2), 

substantivo(2,3). 

onde os argumentos indicam os nós do grafo. 



Exemplo 

frase(K,L) :-: 

sintagmaNominal(K,M), predicado(M,N), 

period(N,L). 

sintagmaNominal(K,L) :-: 

artigo(K,M), 

substantivo(M,L). 

predicado(K,L) :-: 

verbo(K,M), sintagmaNominal(M,L). 

predicado(K,L) :-: 

verbo(K,L). 

artigo(K,L) :-: 

o(K,L). 

artigo(K,L) :-: 

a(K,L). 

substantivo(K,L) :-: 

menino(K,L). 


menina(K,L). 


gato(K,L). 


cachorro(K,L). 

verbo(K,L) :-: 

viu(K,L). 


mordeu(K,L). 


dormiu(K,L). 


chamou(K,L). 



Exemplo 

o(1,2). cachorro(2,3). 

mordeu(3,4). o(4,5). 

gato(5,6). ponto(6,7). 

?- frase(1,7). 

yes 

?- frase(X,Y). 

X = 1 

Y = 7 

yes 

 

 

 

o cachorro mordeu o gato . 

1 2 3 4 5 6 7 



DCG 

Para representar uma DCG deve-se definir as 

cláusulas usando o operador “--“ 

-->”. 

Os terminais são indicados entre colchetes ( [ ]). 

Terminais podem conter argumentos. 

Pode-se especificar rotinas a serem executadas 

durante a validação de uma cláusula através de 

chaves ({ }). 



Exemplo 

frase --> > sintagmaNominal, predicado, ['.']. 

']. 

sintagmaNominal --> > artigo, substantivo. 

predicado --> > verbo, sintagmaNominal. 

predicado --> > verbo. 

artigo --> > [o]; [a]. 

substantivo --> > [menino] ; [menina] ; 

[cachorro] ; [gato]. 

verbo --> > [viu] ; [chamou] ; [dormiu] ; 

[mordeu]. 



Exemplo 

frase(fr(N,P)) --> > sintagmaNominal(N), predicado(P), 

['.']. 

sintagmaNominal(sintagN(D,N)) --> > artigo(D), 

substantivo(N). 

predicado(pred(V,N)) --> > verbo(V), 

sintagmaNominal(N). 

predicado(pred(V)) --> > verbo(V). 

artigo(art(o)) --> > [o]. 

artigo(art(a)) --> > [a]. 

substantivo(sub (menino)) --> > [menino]. 

substantivo(sub (menina)) --> > [menina]. 

substantivo(sub (gato)) --> > [gato]. 

substantivo(sub (cachorro)) --> > [cachorro]. 

verbo(verb(viu)) --> > [viu]. 

verbo(verb(mordeu)) --> > [mordeu]. 

verbo(verb(dormiu)) --> > [dormiu]. 

verbo(verb(chamou)) --> > [chamou]. 



Exemplo 

?- frase(F, [o,cachorro,mordeu,o,gato,'.'], 

[]). 

F = fr(sintagN(art(o), sub (cachorro)), 

pred(verb(mordeu), sintagN(art(o), 

sub(gato)))) 

yes 

?- predicado(F, [mordeu,o,gato], []). 

F = pred(verbo(mordeu), sintagN(art(o), 

sub(gato))) 

yes 



Scanner 

::= | . 

 

::= . 

::= ε | . 

 

getnum(C,N) :-: 

digit(C), get0(D), restnum(D,Lc), 

name(N,[C|Lc]). 

restnum(C,[C|Lc]) :-: 

digit(C), get0(D), restnum(D,Lc). 

restnum(C,[]). 



Scanner 

scan([T|Lt]) :-: 

getch(C), gettoken(C, T, D), 

restprog(T, D, Lt), !. 

getch(C) :-: 

get0(C), (endline(C),nl; endfile(C), 

nl ; put(C)). 

restprog(eop, C, []). 

restprog(T, 

C, [U|Lt]) :-: 

gettoken(C, U, D), 

restprog(U, D, Lt). 



Invocando Rotinas 

scanp :-: 

nl, write('Scan & Parse'), nl, nl, 

write('Enter name of source file: '), nl, 

getfilename(FileName), nl, see(FileName), 

scan(Tokens), seen, write('Scan ok'), nl, !, 

write(Tokens), nl, nl, parse(ParseTree,Tokens), 

write('Parse ok'), nl, !, write(ParseTree), nl, nl. 

getfilename(W) :-: 

get0(C), restfilename(C,Cs), 

name(W,Cs). 

restfilename(C,[C|Cs]) :-: 

filechar(C), get0(D), 

restfilename(D,Cs). 

restfilename(C,[]).

Linguagens Lógicas & Prolog - PUC-Rio

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?