1 / 30

Jacques Robin Ioram Schechtman Sette DI-UFPE

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

adara
Télécharger la présentation

Jacques Robin Ioram Schechtman Sette DI-UFPE

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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 :=

More Related