introdu o a life logic inheritance functions equations uma linguagem multiparadigma a base l gica
Download
Skip this Video
Download Presentation
Jacques Robin Ioram Schechtman Sette DI-UFPE

Loading in 2 Seconds...

play fullscreen
1 / 30

Jacques Robin Ioram Schechtman Sette DI-UFPE - PowerPoint PPT Presentation


  • 90 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Jacques Robin Ioram Schechtman Sette DI-UFPE' - adara


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
slide5

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
slide12

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

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

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