Introdução a LIFE Introdução a LIFE (Logic Inheritance Functions (Logic Inheritance Functions
Equations):Equations):uma linguagem multiparadigmauma linguagem multiparadigma
a base lógicaa base lógica
Jacques RobinIoram Sette Schechtman
DI-UFPE
Motivação: Motivação: Limitações de Prolog como LPLimitaçõ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 ordemex, > ?- C is D, D = 1 + 2.
Error.
Limitações de Prolog como LP (cont.)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 Limitações de Prolog como Formalismo de Representação de Conhecimento de Representação de Conhecimento
(FRC)(FRC)
Hipótese do mundo fechado• inadequação inferencial com conhecimento parcial
ex, pessoa(joao,35,consultor) não unifica com pessoa(joao, consultor,maria)
• LIFE OK Respostas para consultas sempre extensionais
• inadequação expressiva para resolução de restriçõesex, 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
LeFun Prolog Funcional
A Química de LIFE: A molécula
-cálculo Tipos, herança, FUF, Redes Semânticas
-cálculo Funções ProcedimentosDaemons,Métodos
LogIn Prolog OOLIFE
Frames+Regra
-cálculo Relações. Regras, Lógica.
FOOL Frames CLOS
Estrutura de dado de LIFE: termo Estrutura de dado de LIFE: termo
Forma genérica:• termo --> Sort | Sort(atributo1, ..., atributoN) Variável | Variável:Sort | Variável:Sort(atr1, ...,
atrN) | Variável:@(atr1, ..., atrN) • atrI -->valorAtr | nomeAtr => valorAtr• nomeAtr -->inteiro | átomo • valorAtr --> termo • Sort --> builtInSort | UserDefinedSort
Diferenças essenciais com termo Prolog:• Variáveis em qualquer nó da árvore (não apenas nas folhas)• Sem aridade fixa• Sorts são tipos hierarquizáveis • termo assinatura de classe em POO
Exemplos de termos Exemplos de termos
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
rótulos não numéricos
Exemplos de termos Exemplos de termos (cont.) (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 TiposHierarquia 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 SortsBuilt-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 Sorts (hierarquia)
@
list boolrealstring
cons int true[ ] false
built_in
{ }
glb (Greatest Lower Bound)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)glb (hierarquia de sorts)
pessoapessoa
empregadoempregado estudanteestudante
staffstaff professor professor
est_trabest_trab
s1 sn w1 w2 e1 e2 f1 f2 f3s1 sn w1 w2 e1 e2 f1 f2 f3
AtributosAtributos
Par consistindo em um rótulo e um termo 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áveisVariáveis
Começam por _ ou letra maiúscula
Variável Anônima: _ (equivalente a @)
Pode ser associada a um termo 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 Exemplo de termo pessoa pessoa
X:pessoa(nome=>id(primeiro=>string,X:pessoa(nome=>id(primeiro=>string, último=>S:string),último=>S:string),
conjuge=>pessoa(nome=>id(último=>S),conjuge=>pessoa(nome=>id(último=>S), conjuge=>X)).conjuge=>X)).
nomenomepessoapessoa idid
primeiroprimeiro ultimoultimoconjugeconjuge string string string string
nomenome ultimo ultimopessoapessoa id id
Caracteristicas de termos Caracteristicas de termos
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:{charlataoP:{charlatao ;pessoa(id=>nome(primeiro=>X:’john’’,;pessoa(id=>nome(primeiro=>X:’john’’,
ultimo=>Y:{‘doe’;X}),ultimo=>Y:{‘doe’;X}), amigo=>{P;pessoa(id=>nome(primeiro=>Y,amigo=>{P;pessoa(id=>nome(primeiro=>Y,
último=>X))})}último=>X))})}
UnificaçãoUnificação
Unificar 2 termos consiste em:• computar o glb de seus sort principais,• casar as variáveis principais,• ligá-las a todos os atributos dos 2 termos pais,• unificar recursivamente os termos relativos aos atributos.
Se durante a unificação o glb for { }, ela falha, caso contrário ela sucede.
Exemplo de UnificaçãoExemplo de Unificação
pessoapessoa
empregadoempregado estudanteestudante
staffstaff professor professor
est_trabest_trab
s1 sn w1 w2 e1 e2 f1 f2 f3s1 sn w1 w2 e1 e2 f1 f2 f3
Exemplo de Unificação (cont.)Exemplo de Unificação (cont.)
X:estudante(orientador => professor( secretária=>Y:staff,X:estudante(orientador => professor( secretária=>Y:staff, assistente=>X),assistente=>X), colega_de_quarto=>empregado(representante=>Y)).colega_de_quarto=>empregado(representante=>Y)).
empregado(orientador=>empregado(orientador=>f1f1(secretária=>empregado,(secretária=>empregado, assistente=>U:pessoa),assistente=>U:pessoa),
colega_de_quarto=>V:estudante(representante=>V),colega_de_quarto=>V:estudante(representante=>V), ajudante=>ajudante=>w1w1(esposa=>U))(esposa=>U))
UnificaçãoUnificação::W:est_trab(orientador=>W:est_trab(orientador=>f1f1(secretária=>Z:est_trab(representante(secretária=>Z:est_trab(representante=>Z),=>Z), assistente=>W), assistente=>W),
colega_de_quarto=>Z,colega_de_quarto=>Z, ajudante=>ajudante=>w1w1(esposa=>W))(esposa=>W))
Exemplo de unificação (cont.)Exemplo de unificação (cont.)
YresentanteQuarto.repX.colegaDe
empregadoQuartoX.colegaDe
Xnteor.assisteX.orientad
staffY riaor.secretaX.orientad
professororX.orientad
estudanteX
U.esposaW.ajudante
w1W.ajudante
VresentanteQuarto.repW.colegaDe
estudanteVQuartoW.colegaDe
pessoaUnteor.assisteW.orientad
empregadoriaor.secretaW.orientad
f1orW.orientad
empregadoW
W.esposaW.ajudante
w1W.ajudante
ZQuartoW.colegaDe
Wnteor.assisteW.orientad
Zentanteria.represor.secretaW.orientad
est_trabZriaor.secretaW.orientad
f1orW.orientad
est_trabW
Exemplo de Unificação (cont.)Exemplo de Unificação (cont.)
X:estudante(orientador => X:estudante(orientador => professor( secretária=>Y:staff,professor( secretária=>Y:staff,
assistente=>X),assistente=>X), colega_de_quarto=>empregado(representante=>Y)).colega_de_quarto=>empregado(representante=>Y)).
estudante professor
staff
colega_de_quarto secretária
assistente
orientador
representante
X
Y
Exemplo de Unificação (cont.)Exemplo de Unificação (cont.)
empregado f1
estudante
colega_de_quarto
secretária
assistente
orientador
representante
empregado(orientador=>empregado(orientador=>f1f1(secretária=>empregado,(secretária=>empregado, assistente=>U:pessoa),assistente=>U:pessoa),
colega_de_quarto=>V:estudante(representante=>V),colega_de_quarto=>V:estudante(representante=>V),ajudante=>ajudante=>w1w1(esposa=>U))(esposa=>U))
empregado
pessoa
w1
ajudante
esposa
U
V
Exemplo de Unificação (cont.)Exemplo de Unificação (cont.)
est_trab f1
est_trab
colega_de_quarto secretária
assistente
orientador
representante
Unificação:Unificação:W:est_trab(orientador=>W:est_trab(orientador=>f1f1(secretária=>Z:est_trab(representante(secretária=>Z:est_trab(representante=>Z),=>Z), assistente=>W), assistente=>W),
colega_de_quarto=>Z,colega_de_quarto=>Z, ajudante=>ajudante=>w1w1(esposa=>W))(esposa=>W))
w1esposa
ajudante
Declaração de Atributos em Sorts Declaração de Atributos em Sorts (Classes)(Classes)
:: Headonde Head é um termo 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?
*** YesA = 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 AtributosExemplo 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)?*** YesR=rectangle(area=>16, lenght=>4, width=>4).
R=square? *** YesR = square(area=>16, lenght => _A: 4, side => _A, width => _A).
Declaração de Sorts com RestriçõesDeclaraçã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 SortsPossí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 Notar a Assimetria de comportamento de :=:=
t := {u;v;w}. abreviau <| t . v <| t . w <|t .
t := {u}. abreviau <| 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).
Versatilidade dos termos Versatilidade dos termos
Termo- como declaração de classe:• :: termo-• :: sort(atr1 => val1, ..., atrN => valN).
Termo- como cláusula lógica (definição de predicado):• termo-0 :- termo-1, ..., termo-M.• predA(argA1 => valA1, ..., argAn => valAn)
:- predB(argB1 => valB1, ..., argBn => valBn),
...
predK(argK1 => valK1, ..., argKn => valKn). Termo- como cláusula funcional (definição de função):
• termo-0 -> termo-1.• funcA(paramA1 => valA1, ..., paramAn => valAn)
-> funcB(paramB1 => funcC(paramC1 => ... => val1) ...), ...
paramBK => funcI(paramI1 => valAn, ...)).