Introdução

Lógica vem do latim “logos”:

logos :
a) Raciocínio
b) Discurso (expressão
( ã linguística
l í d
do
raciocínio)

Contribui a base para o Método

Ci ífi
Científico
 Histórico
390 AC‐
AC 1840 DC: Por quase 2000 anos
predominou a lógica aristotélica, onde a
argumentação
g ç é baseada em 3 p proposições
p ç –2
premissas e uma conclusão:
1. Todo homem é mortal.
2. Sócrates é um homem.
3. Sócrates é mortal.
Tal argumentação é conhecida como cilogismo.
p modus p
Exemplo: ponen
 Concepção atual
É derivada do livro “Princípio
Princípio da Mathematica”
Mathematica ,
escrito por Berthand Russel e Alfred
Whitehead (1913
(1913‐1915
1915 – 3 volumes)
Ex: ver Paradoxo de Russel.

Hilbert : automatização da teoria da prova.

Gödel: teoria de incompletude

incompletude.
 Bibliografia

Logic and Structure

Dirk van Dalen
4th Edition

A Mathematical
Introduction to Logic,
Logic
Herbert B. Enderton
Second Edition
 Bibliografia

Introduction to
Mathematical Logic,
Elliott Mendelson
Fourth Edition

Lógica
Ló i para Ciência
Ciê i dad
Computação,
J ã Nunes
João N d SSouza
de
 Avaliação
• VE : 1 ou 2
• VI : ?
• 1 trabalho
b lh em Prolog
l
• 1 VC
• 1 VF
Programação
g ç em lógica
g
1. Introdução ‐ PROLOG
2. Resolução SLD.
3. Semânticas de Prologg
Cálculo proposicional
1. Consequência semântica (avaliação).
2. Consequência
q lógica
g ((dedução
ç natural).)
Lógica de primeira ordem
1. Consequência semântica (interpretação).
2. Consequência
q lógica
g ((dedução
ç natural).)
Outras formas de derivação (consequência lógica)
1. Sistema axiomático para o cálculo proposicional e a lógica de primeira
ordem.
2. Tableaux semântico para o cálculo proposicional e lógica de primeira
ordem.
3. Resolução para o cálculo proposicional e a lógica de primeira ordem.
Lógica de descrição
Problemas em Prolog
Observação
 Prolog
• Prologg é uma linguagem
g g de p
programação
g ç “declarativa” q
que se
enquadra no paradigma de Programação em Lógica
Matemática.

• É uma linguagem de uso geral que é especialmente associada

com a inteligência
g artificial e lingüística
g computacional.
p

• Consiste numa linguagem puramente lógica estendida com

componentes extra‐lógicos.
 Continuação
• Programming in Logic
• Desenvolvido em 1970’s
• ISO
SO standard
d d publicado
bli d iin 1996
996
 Aplicações de Prolog

– Engenharia de Software (especificação formal, linguagens

de programação);
– IA (raciocino e Representação do Conhecimento )), sistemas
especialistas;
– Banco de Dados ‐ Dedutivos (BDDs);
– Teoria Lógica (TL) das provas;
– Jogos;
– Lingüística Computacional;
– Processamento de linguagem natural;
 Prolog
• Cláusula de Horn é uma cláusula com no máximo um literal positivo.
upqt u :‐ p, q, ..., t

• Cláusula definida (ou regra) é uma cláusula de Horn com um literal

positivo e literais negativos.

• Cláusula fato é uma cláusula de Horn sem literais negativo.

Representada por v:‐ . ou v.

• Cláusula objetivo é uma clausula sem literal positivo. Representada

por :‐ q .
 Algumas Implementações
LPA Prolog (http://www.lpa.co.uk/)
O
Open Prolog
P l (h //
(http://www.cs.tcd.ie/open‐prolog/)
di / l /)
Ciao Prolog (http://www.clip.dia.fi.upm.es/Software/Ciao)
GNU Prolog (http://gnu‐prolog.inria.fr)
YAP Prolog (http://www.ncc.up.pt/~vsc/Yap)
SWI Prolog (http://www.swi‐prolog.org)
Strawberry Prolog (http://www.dobrev.com/)
SICStus Prolog (http://www.sics.se/sicstus/)
Amzi! Prolog (http://www.amzi.com/)
B‐Prolog (http://www.probp.com/)
tuProlog (http://tuprolog.sourceforge.net/) ‐ Código Aberto integrável ao Java
XSB (http://xsb.sourceforge.net/)
Trinc Prologg ((http://www.trinc‐prolog.com)
p // p g )
hProlog ( http://www.cs.kuleuven.ac.be/~bmd/hProlog/ )
ilProlog ( http://www.pharmadm.com/dmax.asp )
CxProlog ( http://ctp.di.fct.unl.pt/~amd/cxprolog/ )
NanoProlog ( http://ctp.di.fct.unl.pt/
http://ctp di fct unl pt/~amd/cxprolog/
amd/cxprolog/ )
Visual Prolog ( http://visual‐prolog.com/ )
 Cláusulas de Horn
Cabeça e corpo da regra u :‐ p, q, ..., t
U é a cabeça e p, q, ..., t é o corpo da regra

EExemplo:
l
passaro(X) :‐ animal(X), tem_penas(X).

passaro(X) ‐ cabeça da regra.

animal(X), tem_penas(X) ‐ corpo da regra.

Cláusula de Horn “safe” – todas as variáveis que aparecem na

cabeça
ç aparem
p no corpo
p da regra.
g
 Cláusulas de Horn
valioso(ouro).
( )
gosta(Paulo,X) :‐ gosta(X,vinho).
sexo_feminino(jane).
passaro(X) :‐ animal(X), tem_penas(X).
pai(john,mary).
irma(X,Y)
( ) :‐ sexo_feminino(X),
( ) pais(M,F,X),
( ) pais(M,F,Y).
( )

Obs: Geralmente variáveis representadas por letras maiúsculas e

constantes representadas por letras minúsculas (depende a
implementação).
 Trabalho
1.Escolher
1 Escolher um tema (problema para ser
resolvido em Prolog)
2 Criar uma interface (o módulo de
2.Criar
visualização).
3P
3.Prazo ( ó a VC)
(após
4.Relatório
Obs: O SICStus Prolog inclui a possibilidade de criação de sockets
permitindo a comunicação com o módulo de visualização.
 Relatório
1. Capa: Elementos de identificação do trabalho e do grupo.
2. Introdução: Descrição dos objetivos e motivação do trabalho, e
estrutura do mesmo.
3. Descrição do Problema: Descrevendo sucintamente o jogo, a sua
história e regras
4. Arquitetura do Sistema: Descrevendo em linhas gerais o sistema, os
módulos que o constituem, a comunicação com o visualizador, sintaxe
das mensagens trocadas.
5. Lógica do programa, descrevendo o algoritmo e cada predicado usado.
6. Interface com o Utilizador: Descrevendo resumidamente o módulo de
interface com o utilizador
7. Conclusões e Perspectivas de Desenvolvimento
8. Bibliografia.
 Temas para o trabalho
a) Sistema de reservas passagens. Alguns parâmetros poderiam ser sem
mudar de cias aéreas, menor distancias voada, número de escalas, menor
preço, menor tempo (levando em conta o horários de vôos e conexões),
fazendo escalas em determinadas cidades.

O usuário entraria o trajeto (podendo ser passando por várias cidades) e suas
preferências.

b) Jogo “ four in a row”

 Temas para o trabalho
c) O problema da coloração de mapas planares por apenas 4 cores,
mapeados como pontos em NxN e retas unindo esses pontos.

d)) Master Mind

Os alunos teriam que implementar duas opções:
1. o usuário joga a cada vez e 0 programa responde quantas acertou na
posição correta e quantas na errada (evidentemente sem dizer qual)
qual).
2. o usuário faz uma jogada inicial e o programa vai criando novas jogadas,
consistentes com cada nova resposta e as respostas anteriores.
Sugestão: começar sem repetição de cores.
cores

e) Jogo de damas.
Tabuleiro com configuração inicial. Um usuário jogar com o sistema. Colocar
diferentes graus de “inteligência”.
 Temas para o trabalho
g) Jogo de dominó com 1 jogador. Colocar diferentes graus de “inteligência”.
h) O problema social do jogador de golfe (Social Golfer Problem)
Consiste agendar g*s jogadores de golfe em g grupos de s de jogadores em w
semanas,, de forma q
que todo jjogador
g jjogue
g no mesmo ggrupo p de outro jogador
j g
exatamente do uma vez.

O problema pode ser visto como um problema de otimização se para dois

números dados g e s nós pedimos o número máximo de semanas onde os
jogadores de golfe podem jogar junto:

Dada a tripla (w,g,s), achar w máximo tal que (w,8,4).

N
Nesse caso w a melhor
lh solução
l ã encontrada
d (w
( max)) é w=9
9.
 Continuação
O exemplo 7‐5‐3 é equivalente ao problema de Thomas Kirkman
Quantos dias são necessários para que 15 alunas formem por dia 5 grupos de 3
meninas, de forma cada menina esteja no mesmo grupo de qualquer outra em
apenas um dia ?
grupo 1 grupo 2 grupo 3 grupo 4 grupo 5
Dia 1 ABC DEF GHI JKL MNO
Dia 2 ADG BEJ CFM HKN ILO
Dia 3 AEN BDO CHL FIK GJM
Dia 4 AIM BGL CDK EHO FJN
Dia 5 AHJ BKM CEI DLN FGO
Dia 6 AFL BIN CJO DHM EGK
Dia 7 AKO BFH CGN DIJ ELM

http://www.maa.org/editorial/mathgames/mathgames_08_14_07.html
http://www.cs.brown.edu/~sello/golf.html
 Outros jogos
Outros jogos possíveis que possuem as características desejadas são:
a) Blokus (http://www.blokus.com/)
b) Blokus Trigon (http://www.blokus.com/)
c) Sputnik (Gigamic)
d) Katamino (Gigamic)
e) Ringgz (Gigamic)
f) Gobblet
G bbl (Gigamic)
(Gi i )
g) Quads (Gigamic)
h) Quoridor Kid (Gigamic)
i) Tortuga (Gigamic)
j) Trax (http://www.traxgame.com/)
k) Tantrix (http://www.tantrix.com/)
(http://www tantrix com/) x/automatonwars/)
 Outros jogos
l) Cathedral (http://www.cathedral‐game.co.nz/)
m)) D i f t the
Desinfect th Core
C (htt
(http://www.thejab.com/newsite/balm.html)
// th j b / it /b l ht l)
n) Cards Labyrinth (Labirinto Mágico) (Ravensburg)
o) Gipf (Gipf Project)
p) Zertz (Gipf Project)
q) Dvonn (Gipf Project)
r) Yinch (Gipf Project)
s) AutomatonWars (http://juegos.terra.com.m

Outros
O t sites
it
http://www.boardgamegeek.com/ http://www.gigamic.com/
p // gp /
http://www.gipf.com/ http://www.brainbashers.com/
p // /
http://www.mathpuzzle.com/
 Prolog – Exemplo 1
pai_mae(ana,carlos).
pai mae(ana,carlos).
pai_mae(paulo,maria).
pai mae(carlos joao).
pai_mae(carlos, joao)
pai_mae(ana,paulo).
pai mae(joao roberto)
pai_mae(joao,roberto).
avo(X,Y) :‐ pai_mae(X,Z), pai_mae(Z,Y).
Consulta ou objetivo
:‐ avo(ana,joao).
:‐ avo(ana,X).
( X)
 Exemplo 2
p(ana,carlos).
p(paulo,maria).
p(carlos joao)
p(carlos, joao).
p(ana,paulo).
p(joao roberto)
p(joao,roberto).
anc(X,Y) :‐ p(X,Y).
anc(X Y) ::‐ p(X,Z),
anc(X,Y) p(X Z) anc (Z
(Z,Y).
Y)
 Exercícios
Ex1 ) Fazer a arvore de derivação SLD no
exemplo 2 para o goal :‐ anc ( ana,Y).

Ex 2) Altere o ex 1 mudando a regra

anc(X,Y) :‐ p(X,Z), anc (Z,Y). para
anc(X,Y)
( , ) :‐ anc ((Z,Y),
, ), p(X,Z).
p( , )
Considere o goal :‐ anc ( ana,Y).
 Semânticas de Prolog
• Resolução
ç SLD e Arvore SLD.
– Regra de computação: unificar com as cláusulas obedecendo a ordem
em que aparecem, e no corpo da cláusula selecionar o literal mais a
esquerda
q – método top‐down.
p
• Modelo mínimo de Herbrand.
– Definir modelo de Herbrand;
– Fazer a interseção de todos os modelos de Herbrand.
– Achar o modelo mínimo de Herbrand ‐ método botton‐up.
• Menor p
ponto fixo do operador
p conseqüência
q imediata.
– Usar o perador Tp ;
– Começar por Tp (Ø);
– Parar quando achar um ponto fixo;
fixo
Método naive e semi‐naive ‐ método botton‐up.
 Arvore SLD
• Prologg executa uma resolução
ç SLD:
S selection rule (em Prolog da esquerda para a direita);
L linear resolution;
D definite clauses;
Regra de computação
• Arvores SLD :
Mostra todos as possíveis resoluções;
Procura em profundidade (depth first) ;
Clausulas escolhidas por ordem no programa;
Literal mais a esquerda é escolhido;
Backtracking.
 Backtracking
Prologg executa uma busca em p
profundidade ((depth‐first
p f search);
);

A árvore é percorrida sistematicamente de cima para baixo e da

esquerda para direita.

Quando falha ou é encontrado um nó terminal da árvore,

árvore
executa backtracking :

Retorna pelo mesmo caminho percorrido com a finalidade de encontrar

soluções alternativas.
 Arvore de resolução SLD
Exemplo
p

p.
r.
t :‐ r.
q.
u :‐ p, q, t.

Consulta :‐ u
Arvore de resolução SLD é ......
 Resolução SLD
p( , ) :‐ p(
p(X,Y) p(X,Z),
, ), p(
p(Z,Y).
, )
p(X,Y) :‐ m(X,Y).
p(X,Y) :‐ f(X,Y).
f(adam,tom).
f(adam,mary).
f(tom,david).
( )
m(mary,anne).

Consulta :‐ p(adam,Y).
Arvore de resolução SLD é ....
 Predicados built‐in
built in
• op
p de unificação
ç =.
• teste e conversão de tipos: atom, integer, real, var, name, etc.
• controle de busca: !, fail, true, repeat
• negação por falha: not
• op aritméticos: is, +, ‐, *, /, rem, mod , ^ , etc.
• op aritméticos de comparação: <, >, =< , >=, =:= , =\=. \
• entrada/saída: read, write, consult, etc.
• meta programação: assert,
meta‐programação: assert retract
retract, call
• Conjuntos is_set(+Set), is_list(+List), list_to_set(+List, ‐
Set),subset(+Subset, +Set), union(+Set1, +Set2, ‐Set3), etc
 Operadores não Lógicos
X = Y , X is Y e X =:= Y são diferentes.

:‐ X = 1 + 2. :‐ X is 1 + 2.
resp: X = 1 + 2 resp: X = 3
:‐ X is 3/2, Y is 3 mod 2. :‐ 277 * 37 > 10000.
resp: X=1.5 Y=1 resp: true
:‐ 1+22 =:= 2
2+1. :‐ 1+22 = 2+1.
2
resp: true resp: false
:‐ 1+A = B+2. : ‐ X=2, Y is X+2, X =\= Y , Z = 8
resp: A=2 B=1 resp: X = 2,Y = 4,Z = 8.
:‐ Y =:= 1. :‐ X=2, Y is X+2, X =:= Y.
ERROR: =:=/2:
: /2: resp: false
:‐ N=2, M=1, N =:= M+1. resp: N = 2,M = 1.
 Leitura ex. 1
pergunta:‐ repeat,
write('Quer
( um restaurante no centro?'),nl,
)
write('1 ‐ Sim'),nl,
write('2 ‐ Nao'),nl,
write('3 ‐ Sair'),nl,
Sair') nl
read(X),
processa(X),
X==3 ! write('Adeus')
X==3,!,write( Adeus ).
processa(1):‐assert(fact(restaurante_a)),!.
processa(2):‐assert(fact(restaurante_b)),!.
p
processa(3):‐!.
( )
processa(_):‐write('Opcao invalida!'),nl,nl.

: pergunta. 2. 3. :‐fact(X).
 Leitura ex. 2
pergunta:‐
p g repeat,
p ,
write('Entre com um nome e sobrenome'),nl,
read(X),
write('entre com a favorita dessa pessoa'),nl,
read(Y),
assert(cor(X,Y)),
( ( ))
write('Entre com s para sair e c para continuar'),nl,
read(Z),
read(Z)
Z== s, !,write('Adeus').
 Torre de Hanoi

hanoi(N) :‐ move(N, 1, 2, 3).

move(0,
(0 _, _, _)) :‐ !.
!

move(N, A
move(N A, B,
B C) :‐ M is N‐1,
N‐1 move(M
move(M, A,
A CC, B)
B), inform(A,
inform(A B),
B)
move(M, C, B, A).

inform(X, Y) :‐ write(‘ mova um disco do pino '),write(X),

write(' para o pino '), write(Y), nl.
Lista
 Unificação em Listas
[ | Y ] ou [[X | [ Y | Z]] ] unificam com [[a,, b,, c,, d].
[X ]
[X, Y, Z] não unifica com [a, b, c, d]

[a, b, c] = [a | [b | [c]]] = [a | [b, c]] = [a, b | [c]] = [a, b, c | []]

As consultas em Prolog:
:‐ [X | Y] = [a, b, c]. X=a Y=[b, c]
::‐ [X,
[X Y,
Y Z] = [a,
[a bb, c,
c d].
d] false
:‐ [X | [Y | Z]] = [a, b, c, d]. X=a Y=b Z=[c, d]
::‐ [X , Y | Z ] = [a,
[a bb, c,
c d].
d] X=a Y=b Z=[c,
Z=[c d]
 Prolog com Lista
membro(X,[X|
( ,[ |_])
]).
membro(X,[Y|Z]) :‐ membro(X,Z).

Consulta
:‐ membro(b,[a,b,c]) .
‐> sim

: membro(X
:‐ membro(X,[a,b,c])
[a b c]) .
‐> X = a ; X = b ; X = c ; no.
Arvore de resolução SLD é ....
 Lista (cont)
Escreva um programa que conte os elementos
de uma lista.

lista(0,[]).

lista(X,[
( ,[_||L])
]) :‐ lista(Y,L),
( , ), X is Y+1 .
 Listas (cont)
Predicado alpha
alpha([ ]],Ys)
Ys) .
alpha([X|Xs],[X|Ys]) :‐ alpha(Xs,Ys).
Consulta: :‐ alpha([a,b],[a,b,c,d]). Arvore de resolução SLD é ....

Predicado append1(Xs,Ys,Zs)
append1([ ],Ys,Ys)
] Ys Ys) .
append1([X|Xs],Ys,[X|Zs]) :‐ append1(Xs,Ys,Zs).
Consultas: :‐ append1 ([a,b],[c,d],[a,b,c,d]).
:‐ append1([a,b],[c,d],[a,b,c,d]). :‐ append1([a,b],[c,d],Y).
:‐ append1([a,b],Y,[a,b,c,d]). :‐ append1(Y,[c,d],[a,b,c,d]).
As arvores de resolução SLD são ....
(note a diferença do resultado da terceira e quarta consulta)
 Listas (cont)
Notação
ç com _
membro(X,[ _|Y]):‐ membro(X,Y).

Exercício
Verifique se podemos definir o predicado membro como função
do predicado append,
append usando apenas a regra
membro(X,Y):‐ append(_,[X|_],Y).
 Listas (cont)
Exercício
rem1(X,[X|L],L).
rem1(X,[Y|L],[Y|L1]) :‐ rem1(X,L,L1).
:‐ rem1(a,[a,b,a],L).
1( [ b ] L) resp: L = [b,
[b a]] ; L = [a,
[ b] ; false.
f l

Exercício
ultimo( X,[ X ]) .
ultimo(X, [ _|Y]) :‐ ultimo(X,Y)
:‐ ultimo(X,[a,b,c,d,a]). X = a ; false.
:‐ ultimo(X,[a,b,c,[d,a]]). X = [d,a] ;false.
::‐ ultimo(X,[a,b,c|[d,a]]).
ultimo(X [a b c|[d a]]) X = a ;false.
;false
 Remove (cont)
Exercício
rem2(X,[ ],[ ]).
rem2(X,[X|L],L1) :‐ rem2(X,L,L1).
rem2(X,[Y|L],[Y|L1])
2(X [Y|L] [Y|L1]) :‐ rem2(X,L,L1).
2(X L L1)
:‐ rem2(a,[a,b,c,a],L).
L = [[b,c]
, ] ; L = [[b,c,a]
, , ] ; L = [a,
[ , b,c]
, ] ; L = [[a,, b,, c,, a]] ; false.

Exercício
rem3(X,[],[]).
rem3(X,[X|L],L1) :‐ rem3(X,L,L1).
rem3(X [Y|L] [Y|L1]) ::‐ not(X
rem3(X,[Y|L],[Y|L1]) not(X=Y)
Y), rem3(X,L,L1).
rem3(X L L1)
X =\= Y gera erro (operador aritmético)
 Remove (cont) e reverte
Exercício
Qual a diferença entre rem1, rem2 e rem3 ?

Exercício.
Escreva um programa que reverta uma lista.
Cut
 Cut (cont)
( )
• A idéia é podar a árvore de prova para evitar ramos
desnecessários e ppodendo tornar o pprograma
g mais eficiente.
• Altera o mecanismo de derivação de Prolog.
• Ob
Obriga
i o programador
d a saber
b como o programa seráá
executado para poder entendê‐lo.
•Comporta‐se
•Comporta se como uma fórmula atômica que é sempre
satisfeita.
É um comando extra lógico . símbolos adicionais comuns: fail,
fail
repeat.
 Cut (cont)
• Instrução
ç imperativa
p (procedural)
(p )qque vai contra a filosofia
“declarativa” da programação em lógica.
( Não é uma boa técnica de p
programação)
g ç )

ex: A :‐ B, C, D. C :‐ M, N, !, P, Q. C :‐ R.
impede backtracking P ‐> N,
permite backtracking N ‐> M, Q ‐> P,
R tentado:
– unicamente se M ou N falha
– nunca se P ou Q falha
 Cut (Cont)
O comando cut permite indicar ao Prolog quais sub‐objetivos já
satisfeitos não necessitam ser reconsiderados. Ele aborta o
processo de backtracking.

Roda mais rápido, sem perder tempo com sub‐objetivos que

não contribuem para determinar a resposta do objetivo
principal.
principal

O programa ocupará menos memória, pois não será necessário

armazenar todos os sub‐objetivos (pontos do backtracking).

O cut pode evitar que o programa entre em laço infinito

infinito.
 Outros exemplos de cut
Exemplo
primogenito(X Y) :‐
primogenito(X,Y) : pai(Y,X),
pai(Y X) masculino(X),
masculino(X) ! .

Exemplo
é
é_cravo(cravo).
( )
flor(cravo).
flor(rosa).
flor(orquidea).
gosta(ana,X) :‐ é_cravo(X), ! ,fail.
gosta(ana X) :‐ flor(X) .
gosta(ana,X)
Perguntas :‐ gosta(ana,cravo). :‐ gosta(ana,rosa) :‐ gosta(ana,X).
Observe que gosta(ana,rosa) é true, mas a consulta gosta(ana,X) não
retorma nenhum valor para X. X
 Caminho com custo
p(a,b,1).
p( , , )
p(b,c,3).
p(c,d,4).
p(d,e,2)
q(X,Y,W) :‐ p(X,Y,W).
q(X,Z,K)
( ) :‐ p(X,Y,W),q(Y,Z,V),
( ) ( ) K is W+V.

: q(a,X,Y).
:‐ q(a X Y)

A arvore de resolução é …….

 Negação
• Não se pode afirmar que NOT é verdadeiro
verdadeiro.

• Usa‐se a hipótese
hi ó do
d mundo
d ffechado
h d (close
( l
world assumption).

• NOT significa
g “Eu não p
posso p
provar que
q é
verdadeiro”
 Predicado not
p(a,b).
p(b,c).
p(c,d).
q(X,Y)
(X Y) :‐ p(X,Y).
(X Y)
q(X,Z) :‐ p(X,Y),q(Y,Z).
rm(X,Y)
( , ) :‐ q(
q(X,Y),
, ), not(p(X,Y)).
(p( , ))

:‐ rm(a,X).

A arvore de resolução é …….