Introdu o a life logic inheritance functions equations uma linguagem multiparadigma a base l gica
This presentation is the property of its rightful owner.
Sponsored Links
1 / 30

Jacques Robin Ioram Schechtman Sette DI-UFPE PowerPoint PPT Presentation


  • 53 Views
  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Introdu o a life logic inheritance functions equations uma linguagem multiparadigma a base l gica

Introdução a LIFE (Logic Inheritance Functions Equations):uma linguagem multiparadigmaa base lógica

Jacques Robin

Ioram Schechtman Sette

DI-UFPE


Motiva o limita es de prolog como lp

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.


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çã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


Limita es de prolog como formalismo de representa o de conhecimento frc

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


Jacques robin ioram schechtman sette di ufpe

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


Estrutura de dado de life termo

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


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


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 cont

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


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

Hierarquia de Tipos


Built in sorts

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


Jacques robin ioram schechtman sette di ufpe

Built-In Sorts (hierarquia)

@

built_in

list

string

real

bool

[ ]

cons

int

true

false

{ }


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


Glb hierarquia de sorts

glb (hierarquia de sorts)

pessoa

empregado

estudante

staff professor

est_trab

s1 sn w1 w2 e1 e2 f1 f2 f3


Atributos

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


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.

Variáveis


Exemplo de termo pessoa

Exemplo de termo  pessoa

nome

pessoaid

primeiroultimo

conjuge string string

nome ultimo

pessoa id

X:pessoa(nome=>id(primeiro=>string,

último=>S:string),

conjuge=>pessoa(nome=>id(último=>S),

conjuge=>X)).


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’’,

ultimo=>Y:{‘doe’;X}),

amigo=>{P;pessoa(id=>nome(primeiro=>Y,

último=>X))})}


Unifica o

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.


Exemplo de unifica o

Exemplo de Unificação

pessoa

empregado

estudante

staff professor

est_trab

s1 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,

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


Exemplo de unifica o cont1

Exemplo de unificação (cont.)


Exemplo de unifica o cont2

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


Exemplo de unifica o cont3

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


Exemplo de unifica o cont4

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


Declara o de atributos em sorts 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.

Declaração de Atributos em Sorts (Classes)


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)?*** 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


Declara o de sorts com restri es

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


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.

Possíveis Declarações de Sorts


Notar a assimetria de comportamento de

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


  • Login