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

Apresentação em tema: "Introdução a LIFE (Logic Inheritance Functions Equations): uma linguagem multiparadigma a base lógica Jacques Robin Ioram Sette Schechtman DI-UFPE."— Transcrição da apresentação:

1

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

3 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ê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 ordem ex, > ?- C is D, D = 1 + 2. Error.

4 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

5 Limitações de Prolog como Formalismo de Representação de Conhecimento (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ções ex, 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

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

7 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

8 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

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 Hierarquia 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

11 Built-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

12 Built-In Sorts (hierarquia) @ listboolrealstring consinttrue[ ]false built_in { }

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

14 glb (hierarquia de sorts) pessoa pessoa empregado empregado estudante estudante staff professor staff professor est_trab est_trab s1 sn w1 w2 e1 e2 f1 f2 f3 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 Variá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.

17 Exemplo de termo pessoa 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)). nome nome pessoaid primeiroultimo primeiroultimo conjuge string string nome ultimo nome ultimo pessoa id

18 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:{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))})}

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 pessoa empregado empregado estudante estudante staff professor staff professor est_trab est_trab s1 sn w1 w2 e1 e2 f1 f2 f3 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), assistente=>X), colega_de_quarto=>empregado(representante=>Y)). colega_de_quarto=>empregado(representante=>Y)). empregado(orientador=>f1(secretária=>empregado, assistente=>U:pessoa), assistente=>U:pessoa), colega_de_quarto=>V:estudante(representante=>V), colega_de_quarto=>V:estudante(representante=>V), ajudante=>w1(esposa=>U)) ajudante=>w1(esposa=>U)) Unificação: W:est_trab(orientador=>f1(secretária=>Z:est_trab(representante=>Z), assistente=>W), colega_de_quarto=>Z, colega_de_quarto=>Z, ajudante=>w1(esposa=>W)) ajudante=>w1(esposa=>W))

22 Exemplo de unificação (cont.)

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

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

25 Exemplo de Unificação (cont.) est_trabf1 est_trab colega_de_quarto secretária assistente orientador representante Unificação: W:est_trab(orientador=>f1(secretária=>Z:est_trab(representante=>Z), assistente=>W), colega_de_quarto=>Z, colega_de_quarto=>Z, ajudante=>w1(esposa=>W)) ajudante=>w1(esposa=>W)) w1 esposa ajudante

26 Declaração de Atributos em Sorts (Classes) * :: Head onde 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? *** Yes A = 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.

27 Exemplo 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) ? *** Yes R=rectangle(area=>16, lenght=>4, width=>4). * R=square? *** Yes R = square(area=>16, lenght => _A: 4, side => _A, width => _A).

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 = = 1, D = = 1, D = = 1, D =< 28. * month_p(jan,1).... month_p(dez,12) month := {month30;month31}.

29 Possí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.

30 Notar a Assimetria de comportamento de := * t := {u;v;w}. abrevia u <| t. v <| t. w <|t. * t := {u}. abrevia u <| 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).

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