Introdução a LIFE
(Logic Inheritance Functions Equations):
uma linguagem multiparadigma
a base lógica
Jacques Robin
Ioram Schechtman Sette
DI-UFPE
Motivação:
Limitações de Prolog como LP


Estrutura de conhecimento:
• de aridade fixa => difícil modificar, estender
• com sub-estruturas indexadas por posição => difícil de ler
• não tipada => difícil verificar, manter consistência
ex, person(_,_,_,_,35,male,_,_,_...)
Aritmética mal integrada com computação simbólica
• dificulta aplicações híbridas
ex, > ?- C is 1 + 2.
C=3
• não tem mais bidirecionalidade, nem declaratividade no
sentido de independente da ordem
ex, > ?- C is D, D = 1 + 2.
Error.
Limitações de Prolog como LP (cont.)



Variáveis de ordem superior não disponíveis
• dificulta meta-programação
ex, P(a,Y)
Interface com protocolos da Internet externa à linguagem
• dificulta programação de agentes na Web
Bibliotecas gráficas externas à linguagem
• dificulta programação de GUIs
Limitações de Prolog como Formalismo de
Representação de Conhecimento (FRC)




Inadequação inferencial com conhecimento parcial
ex, pessoa(joao,35,consultor) não unifica com
pessoa(joao, consultor,maria)
Respostas para consultas sempre extensionais
• inadequação expressiva para resolução de restrições
ex, devolve como resultado: X = 2 mas não X >= 3, Y < 5
Hierarquias representadas por meio de regras
• inadequação aquisicional para conhecimento terminológico
• ineficiência inferencial para herança de propriedades
ex, pessoa(X) :- criança(X). para criança isa pessoa
Procedimentos simulados por encadeamento de regras
• inadequação aquisicional para conhecimento procedimental
A Química de LIFE: A molécula lpy
Y-cálculo
Tipos, herança,
FUF, Redes Semânticas
FOOL
Frames
CLOS
l-cálculo
Funções
Procedimentos
Daemons,Métodos
LogIn
LIFE
Prolog OO
Frames+
Regra
LeFun
Prolog
Funcional
p-cálculo
Relações.
Regras, Lógica.
Estrutura de dado de LIFE: termo y

Sintaxe:
• Alfabeta particionado em 5 espaços de símbolos:


•
•
•
•
sorts, predicados, funções, atributos (constantes) e variáveis
termo y --> sort | Var | Var:sort | Var:sort(atr1, ..., atrN) |
pred(atr1, ..., atrN) |
func(atr1, ..., atrN) | Var(atr1, ..., atrN).
atrI --> valorAtr | nomeAtr => valorAtr
nomeAtr --> inteiro | átomo
valorAtr --> termo y
sort --> builtInSort | userDefinedSort
Versatilidade dos termos y

Termo-y como declaração de classe:
• :: termo-y
• :: sort(atr1 => val1, ..., atrN => valN).

Termo-y como cláusula lógica (definição de predicado):
• termo-y0 :- termo-y1, ..., termo-yM.
• predA(argA1 => valA1, ..., argAn => valAn)
:- predB(argB1 => valB1, ..., argBn => valBn),
...
predK(argK1 => valK1, ..., argKn => valKn).

Termo-y como cláusula funcional (definição de função):
• termo-y0 -> termo-y1.
• funcA(paramA1 => valA1, ..., paramAn => valAn)
-> funcB(paramB1 => funcC(paramC1 => ... => val1) ...), ...
paramBK => funcI(paramI1 => valAn, ...)).
Exemplos de termos y






42, -5.66, “exemplo” : sorts built-in p/ inteiros, reais e
strings
específicos
int, real, string : sorts built-in que denotam todos os
inteiros,
reais e strings.
exemplo_abc, ‘%exemplo^&’ : sorts
date(friday, “XIII”) : sorts c/ atributos e rótulos
numéricos implicitos
date(1=>friday, 2=>”XIII”): sorts c/ atributos e rótulos
numéricos explícitos
freddy(nails=>long, face=>ugly): sorts c/ atributos e
Exemplos de termos y (cont.)

@, jogador, jogadorDeFutebol, romário, time
romário(time => flamengo, posição => atacante).
X:jogador
X:atacante(time => T:time, posição => atacante).
X:@(time => T:brasil(atacante => [romário,ronaldo])).

Variáveis nunca em posição de atributo:




• S(A1 => V1, A2 => atacante(A3 => V3)) gera erro de sintaxe
Hierarquia de Tipos

Sorts:
• Conjunto Parcialmente
Ordenado de Tipos
• Hierarquia definida pelo
operador:
<|
(é um subsort de)
• { } <| sort <| @

Exemplos:
• truck <| vehicle.
(truck é um subsort de vehicle)
• mobile(vehicle).
• useful(truck).
• mobile(X), useful(X)?
• X = truck
Built-In Sorts

Além de {} (bottom) e @ (top):
• todos os inteiros e reais
1 <| int. 1.2 <| real.
• list, [ ] ou nil, cons
[a,b,c] = [a,b|[c]] = [a,b,c|[]] =
[a|[b|[c|[]]]]
• strings
“exemplo” <| string.
• bool, true, false
• built_in (supersort de list, string,
real e bool)

Resumindo:
• built_in <| @
•
•
•
•
list <| built_in
string <| built_in
real <| built_in
bool <| built_in
• cons <| list
• [] <| list
• int <| real
• true <| bool
• false <| bool
Built-In Sorts (hierarquia)
@
built_in
list
[]
string
cons
real
int
{}
bool
true
false
glb (Greatest Lower Bound)




O glb de dois sorts r e s é o
maior subsort comum entre
r e s.
Semântica dos sorts baseada
na teoria dos conjuntos, glb
corresponde a interseção
entre eles.
Se glb é {}, os sorts são ditos
incompatíveis.
O glb pode ser dado pela
forma disjuntiva {s1;s2;s3}
caso seja composto por mais
de um sort.












estudante <| pessoa.
empregado <| pessoa.
staff <| empregado.
est_trab <| estudante.
est_trab <| staff.
s1 <| estudante.
s2 <| estudante.
w1 <| est_trab.
w2 <| est_trab.
e1 <| staff.
e2 <| staff.
glb(estudante,empregados) =
{est_trab}
glb (hierarquia de sorts)
pessoa
empregado
estudante
staff
professor
w2 e1 e2
f1 f2 f3
est_trab
s1
sn
w1
Atributos


Par consistindo em um rótulo e um termo y associado.
Exemplos:
• show(
titulo => “bewitched”,
genero => sitcom,
onde => televisao,
sogra => “Agnes Moorehead”).
• thing(a,b,c) é equivalente a thing(1 => a, 2 => b, 3=>c).
Variáveis





Começam por _ ou letra
maiúscula
Variável Anônima: _
(equivalente a @)
Pode ser associada a um termo y
Ex: X:t
Referência cíclica:
X:[42|X]
Associação implícita: X:@

Exemplos:
• father(name => N:string,
son => boy(name => N))
representa um pai que tem um
filho com o mesmo nome.
• [A,A]
é a lista onde o primeiro e
segundo elemento são identicos.
• L:[int,int,int|L]
lista cíclica de tamanho 3, onde
os 3 elementos são inteiros.
Exemplo de termo y pessoa
nome
pessoa
id
primeiro
conjuge
string
ultimo
string
nome
pessoa
ultimo
id
X:pessoa(nome=>id(primeiro=>string,
último=>S:string),
conjuge=>pessoa(nome=>id(último=>S),
conjuge=>X)).
Caracteristicas de termos y




Recursivo,expressivo,simples e eficiente.
Co-referência x Caminhos.
Mais semântica : Propriedades por rótulo, não por posição, como
Prolog.
Pode ter disjunções :
P:{charlatao
;pessoa(id=>nome(primeiro=>X:’john’’,
ultimo=>Y:{‘doe’;X}),
amigo=>{P;pessoa(id=>nome(primeiro=>Y,
último=>X))})}
Unificação

Unificar 2 termos y consiste em:
•
•
•
•

computar o glb de seus sort principais,
casar as variáveis principais,
ligá-las a todos os atributos dos 2 termos y pais,
unificar recursivamente os termos y relativos aos atributos.
Se durante a unificação o glb for { }, ela falha, caso
contrário ela sucede.
Exemplo de Unificação
pessoa
empregado
estudante
staff
professor
w2 e1 e2
f1 f2 f3
est_trab
s1
sn
w1
Exemplo de Unificação (cont.)
X:estudante(orientador => professor( secretária=>Y:staff,
assistente=>X),
colega_de_quarto=>empregado(representante=>Y)).
empregado(orientador=>f1(secretária=>empregado,
assistente=>U:pessoa),
colega_de_quarto=>V:estudante(representante=>V),
ajudante=>w1(esposa=>U))
Unificação:
W:est_trab(orientador=>f1(secretária=>Z:est_trab(representante=>Z),
assistente=>W),
colega_de_quarto=>Z,
ajudante=>w1(esposa=>W))
Exemplo de unificação (cont.)
X  estudante

X.orientador  professor



X.orientador.secretaria  Y  staff 


X.orientad
or.assiste
nte

X


X.colegaDeQuarto  empregado



X.colegaDeQuarto.representante  Y 
W  empregado
W.orientador  f1

W.orientador.secretaria  empregado
W.orientador.assistente  U  pessoa


W.colegaDeQuarto  V  estudante
W.colegaDeQuarto.representante  V

W.ajudante  w1
W.ajudante.esposa  U
W  est_trab
W.orientador  f1

W.orientador.secretaria  Z  est_trab
W.orientador.secretaria.representante  Z


W.orientador.assistente  W
W.colegaDeQuarto  Z

W.ajudante  w1
W.ajudante.esposa  W
Exemplo de Unificação (cont.)
X
estudante
orientador
assistente
professor
colega_de_quarto
secretária
staff
Y
representante
X:estudante(orientador => professor( secretária=>Y:staff,
assistente=>X),
colega_de_quarto=>empregado(representante=>Y)).
Exemplo de Unificação (cont.)
empregado
f1
secretária
empregado
assistente
colega_de_quarto
ajudante
V
estudante
representante
orientador
pessoa
U
esposa
w1
empregado(orientador=>f1(secretária=>empregado,
assistente=>U:pessoa),
colega_de_quarto=>V:estudante(representante=>V),
ajudante=>w1(esposa=>U))
Exemplo de Unificação (cont.)
w1
esposa
ajudante
est_trab
orientador
f1
assistente
colega_de_quarto
secretária
est_trab
representante
Unificação:
W:est_trab(orientador=>f1(secretária=>Z:est_trab(representante=>Z),
assistente=>W),
colega_de_quarto=>Z,
ajudante=>w1(esposa=>W))
Declaração de Atributos em Sorts (Classes)




:: Head
onde Head é um termo y
arbitrário.
:: person (age=> int).
Assegura que todo termo com o
sort person terá um campo age
cujo valor é um inteiro.
man <| person.
A = man?
*** Yes
A = man(age=>int).



:: vehicle(make => string,
wheels => int).
:: car(wheels => 4).
Se a relação car <| vehicle
existir, todas as propriedades
de car devem ser compatíveis
com as de vehicle.
Exemplo de Declaração de Atributos

:: rectangle(lenght=>L:real,
width=>W:real,
area=>L*W).

:: square(lenght=>S, width=>S,
side =>S).

square <| rectangle.


R=rectangle(area=>16,width=>4)
?
*** Yes
R=rectangle(area=>16,
lenght=>4,
width=>4).
R=square?
*** Yes
R = square(area=>16,
lenght => _A: 4,
side => _A,
width => _A).
Declaração de Sorts com Restrições
::Head | Goal.
 ex, ::X:person | X.age = int.

herança de X.age=int em todas as instâncias de person
exatamente como :: person(age=>int).
 ::date(day_of_week => day_of_week,
day_of_month => D:int,
month_name => Mname:month,
month_num => Mnum:month_num,
year => Y:int) | day_month_p(D,Mname,Y),
month_p(Mname,Mnum).
day_month_p(D,month31,_) :- D >= 1, D =< 31.
day_month_p(D,month30,_) :- D >= 1, D =< 30.
day_month_p(D,feb,Y) :- leaf_year(Y), D >= 1, D =< 29.
day_month_p(D,feb,Y) :- \+(leaf_year(Y)), D >= 1, D =< 28.
 month_p(jan,1).
... month_p(dez,12)
month := {month30;month31}.

Possíveis Declarações de Sorts










:: t (atr).
:: t (atr) | restrições.

t (atr) <| u.
t (atr) <| u | restrições.

t := u (atr).
t := u (atr) | restrições.

t (atr) <| {u;v;w}.
t (atr) <| {u;v;w} | restrições.

t := {u (atr); v (atr); w(atr)}.
t := {u (atr); v (atr); w(atr)} | rest.






::car(wheels=>4).
::car | car.wheels = 4.
car(wheels=>4) <| vehicle.
car <| vehicle | car.wheels = 4.
car := vehicle(wheels => 4).
car := vehicle(wheels => X:int) | X=4.
car <| {four_wheels;vehicle}.
car <| {four_wheels;vehicle} |
vehicle.wheels = 4.
tree := {leaf;node}
tree := {leaf;node} | node.left = tree,
node.right=tree.
Notar a Assimetria de comportamento de :=
t := {u;v;w}. abrevia
u <| t . v <| t . w <|t .
 t := {u}. abrevia
u <| t .
mas
 t := u. abrevia
t <| u.

Exemplo:
 tree := {leaf;
node( left => tree,
right => tree)}
é igual a
 leaf <| tree.
 node <| tree.
 :: node (left => tree,
right => tree).
