jacques robin ioram sette schechtman di-ufpe

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


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


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


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, ...)).

jacques robin ioram sette schechtman di-ufpe

Documents