Jacques Robin Ioram Schechtman Sette DI-UFPE

1. Introdução a LIFE (Logic Inheritance Functions Equations):uma linguagem multiparadigmaa base lógica Jacques Robin Ioram Schechtman Sette DI-UFPE

2. 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ênciaex, person(_,_,_,_,35,male,_,_,_...) • Aritmética mal integrada com computação simbólica • dificulta aplicações híbridasex, > ?- 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.

3. Limitações de Prolog como LP (cont.) • Variáveis de ordem superior não disponíveis • dificulta meta-programaçãoex, 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

4. Limitações de Prolog como Formalismo de Representação de Conhecimento (FRC) • Inadequação inferencial com conhecimento parcialex, 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çõ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 propriedadesex, pessoa(X) :- criança(X). para criança isa pessoa • Procedimentos simulados por encadeamento de regras • inadequação aquisicional para conhecimento procedimental

5. A Química de LIFE: A moléculalpy Y-cálculo Tipos, herança, FUF, Redes Semânticas FOOL Frames CLOS LogIn • Prolog OO LIFE Frames+Regra l-cálculo Funções Procedimentos Daemons,Métodos p-cálculo Relações. Regras, Lógica. LeFunProlog Funcional

6. Estrutura de dado de LIFE: termo  • Sintaxe: • Alfabeta particionado em 5 espaços de símbolos: • sorts, predicados, funções, atributos (constantes) e variáveis • termo  --> 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  • sort --> builtInSort | userDefinedSort

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

8. 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

9. Exemplos de termos  (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

10. 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 Hierarquia de Tipos

11. Além de {} (bottom) e @ (top): todos os inteiros e reais1 <| 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

12. Built-In Sorts (hierarquia) @ built_in list string real bool [ ] cons int true false { }

13. 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 (Greatest Lower Bound)

14. glb (hierarquia de sorts) pessoa empregado estudante staff professor est_trab s1 sn w1 w2 e1 e2 f1 f2 f3

15. Atributos • 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).

16. 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. Variáveis

17. Exemplo de termo  pessoa nome pessoa id primeiro ultimo conjuge string string nome ultimo pessoa id X:pessoa(nome=>id(primeiro=>string, último=>S:string), conjuge=>pessoa(nome=>id(último=>S), conjuge=>X)).

18. 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:{charlatao ;pessoa(id=>nome(primeiro=>X:’john’’, ultimo=>Y:{‘doe’;X}), amigo=>{P;pessoa(id=>nome(primeiro=>Y, último=>X))})}

19. Unificaçã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.

20. Exemplo de Unificação pessoa empregado estudante staff professor est_trab s1 sn w1 w2 e1 e2 f1 f2 f3

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

22. Exemplo de unificação (cont.)

23. Exemplo de Unificação (cont.) orientador estudante X professor assistente colega_de_quarto secretária staff Y representante X:estudante(orientador => professor( secretária=>Y:staff, assistente=>X), colega_de_quarto=>empregado(representante=>Y)).

24. Exemplo de Unificação (cont.) empregado f1 empregado orientador secretária colega_de_quarto assistente ajudante pessoa U estudante V esposa w1 representante empregado(orientador=>f1(secretária=>empregado, assistente=>U:pessoa), colega_de_quarto=>V:estudante(representante=>V), ajudante=>w1(esposa=>U))

25. Exemplo de Unificação (cont.) esposa orientador w1 est_trab f1 ajudante 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))

26. :: 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. Declaração de Atributos em Sorts (Classes)

27. :: 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). Exemplo de Declaração de Atributos

28. 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}.

29. :: 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. Possíveis Declarações de Sorts

30. t := {u;v;w}. abreviau <| t . v <| t . w <|t . t := {u}. abreviau <| t . mas t := u. abreviat <| u. Exemplo: tree := {leaf; node( left => tree, right => tree)} é igual a leaf <| tree. node <| tree. :: node (left => tree, right => tree). Notar a Assimetria de comportamento de :=