LIFE Logic, Inheritance, Functions and Equations

1. LIFELogic, Inheritance, Functions and Equations Ioram Schechtman Sette

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) • Hipótese do mundo fechado • inadequação inferencial com conhecimento parcialex, 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, dá 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, criança isa pessoa • Procedimentos simulados por encadeamento de regras • inadequação aquisicional para conhecimento procedimental

5. The Chemistry of 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 Funcionais

6. Termos • São compostos por • sorts, atributos e variáveis • Exemplos: • 42, -5.66, “exemplo” : sorts p/ inteiros, reais e strings específicos • int, real, string : sorts 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

7. 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(vehicle). mobile(X), useful(X)? X = truck Hierarquia de Tipos

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

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

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

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

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

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

14. Exemplo de termo pessoa nome pessoa id primeiro último cônjuge string string nome último pessoa id X:pessoa(nome=>id(primeiro=>string, último=>S:string), conjuge=>pessoa(nome=>id(último=>S), conjuge=>X)).

15. 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))})}

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

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

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

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

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

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

22. :: 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)

23. :: 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

24. Declaração de Sorts com Restrições • ::Head | Goal.Exs: • :: X:person | X.age = int.Adiciona a propriedade X.age=int em todas as instâncias de person.Mesmo efeito de:: 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 =< 29.

25. :: t (atr). :: t (atr) | rest. t (atr) <| u. t (atr) <| u | rest. t := u (atr). t := u (atr) | restrições. t (atr) <| {u;v;w}. t (atr) <| {u;v;w} | rest. 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

26. t := {u;v;w} é igual au <| t . v <| t . w <|t . t := {u}. é igual au <| t . mas t := u. é igual at <| 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 :=

27. Log In • Log In é simplesmente um Prolog onde os termos de 1a ordem são substituidos por termos , ou seja, com definição de tipos. • Exemplo de Programa em Log In que não seria correto na versão Prolog sem tipos:list:= {[ ]; [ _|list]}.append([ ],L:list,L).append([H|T:list], L:list, [H|R:list]) :- append(T,L,R).

28. Exemplo em Log In coisaboa nota notaboa <| coisaboa. notaboa := {a;b}. notaruim := {c;d;e}. gosta(X:person,X). gosta(peter,mary). gosta(pessoa,coisaboa). tem(peter,c). tem(paul,f). tem(mary,a). feliz(X:pessoa) :- gosta(X,Y),tem(X,Y). feliz(X:pessoa) :- gosta(X,Y),tem(Y,coisaboa). ?- feliz(X). notaboa notaruim a b c d f pessoa estudante peter paul mary

29. Exemplo em Log In (Cont.) coisaboa nota notaboa notaruim ?- feliz(X). X=mary; X=mary; X=peter; No a b c d f pessoa estudante peter paul mary

30. FIM