Frame Logic: Frame Logic: uma linguagem lógica orientada a uma linguagem lógica orientada a

objetos objetos para construção e consultas dedutivaspara construção e consultas dedutivas

de ontologiasde ontologias

Jacques Robin e Franklin RamalhoCIn-UFPE

Frame Logic (F-Logic)Frame Logic (F-Logic) Linguagem integrando 2 paradigmas:

programação em lógica programação orientada a objetos em uma perspectiva de banco de dados

Originada em uma pesquisa teórica sobre semântica formal das linguagens orientado a objetos tanto de programação (Smalltalk) quanto de representação do conhecimento (Sistemas de

frames) quanto de banco de dados (ODMG)

Semântica formal declarativa baseada na lógica de Horn da 1a ordem

Partes de um programa F-LogicPartes de um programa F-Logic1. Declaração da hierarquia de classes e objetos

extend de Java regras definindo um predicado sub em Prolog

2. Definição de objetos new de Java regras definindo um predicado is-a em Prolog

3. Declaração das assinaturas das classes tipagem dos atributos e métodos em Java premissas adicionais de tipagem de argumentos de predicados em

Prolog4. Declaração das regras de dedução entre atributos e métodos

das classes definições de métodos em Java a regras de dedução entre predicados em Prolog

5. Consultas lógicas sobre atributos de objetos consultas lógicas sobre predicados Prolog

Ontologia Especialista – um exemplo Ontologia Especialista – um exemplo acadêmico em F-logic (Flora)acadêmico em F-logic (Flora)

Personaddress : Stringeditor : Publicationemail : Stringfax : StringfirstName : StringlastName : StringmemberOfPC : EventmiddleInitial : Stringname : StringorganizerOrChairOf : Eventphone : Stringphoto : Stringpublication : Publication

Employeeaffiliation : OrganizationheadOf : ProjectheadOfGroup : ResearchGroupworksAtProject : Project

StudentstudiesAt : University

PhDStudentsupervisor : AcademicStaff

ResearchercooperatesWith : ResearchermemberOf : ResearchGroupresearchInterest : ResearchTopic

AcademicStaffsupervises : PhDStudent

Lecturer

AdministrativeStaff

TechnicalStaffSecretarysecretaryOf : ResearchGroup

root[].

person :: root. employee :: person. academicstaff :: employee. researcher :: academicstaff. phdstudent :: researcher. lecturer :: academicstaff. administrativestaff :: employee. secretary :: administrativestaff. technicalstaff :: administrativestaff. student :: person. phdStudent :: student.

Ontologia acadêmica: Ontologia acadêmica: hierarquia de conceitoshierarquia de conceitos

person[photo =>> string,firstname =>> string,middleinitial =>> string,lastname =>> string,name =>> string,address =>> string,email =>> string,phone =>> string,fax =>> string,publication =>> publication,organizerorchairof =>> event,memberOfPC =>> event,editor =>> publication].

Ontologia acadêmica: restrições sobre Ontologia acadêmica: restrições sobre atributos dos conceitosatributos dos conceitos

employee[affiliation =>> organization,worksatproject =>> project,headOf =>> project,headOfgroup =>> researchgroup].

academicstaff[supervises =>> phdstudent].

researcher[researchinterest =>> researchtopic,memberof =>> researchGroup,cooperateswith =>> researcher].

secretary[secretaryof =>> researchgroup].

student[studiesat =>> university].phdstudent[

supervisor =>> academicstaff].

Ontologia acadêmica: instânciasOntologia acadêmica: instânciasjacquesrobin:lecturer[

name ->> 'Jacques Robin',firstname ->> 'Jacques',lastname ->> 'Robin',affiliation ->> ufpe,worksatproject =>> swaip].

franklinramalho:phdstudent[name ->> 'Franklin de Souza Ramalho',firstname ->> 'Franklin',lastname ->> 'Ramalho',address ->> 'Joao Francisco Lisboa, 121, bl-20, apto 304 varzea, Recife PE, Brazil',email ->> 'fsr@cin.ufpe.br',phone ->> 34535677,publication ->> {ir2001, tese2000},studiesat ->> ufpe,supervisor->>jacquesrobin].

Ontologia acadêmica: consultasOntologia acadêmica: consultas

flora2 ?- franklinramalho[publication->>X].X = ir2001X = tese2000

flora2 ?- X:phdstudent.X = franklinramalho

X:lecturer,X[name->>'Jacques Robin'],Y:phdstudent,Y[supervisor->>X].X = jacquesrobinY = franklinramalho

Ontologia acadêmica: Ontologia acadêmica: regras e consultas dedutivasregras e consultas dedutivas

Y:academicstaff[supervises->>X] :- X:phdstudent[supervisor->>Y].jacquesrobin:lecturer[

name ->> 'Jacques Robin',firstname ->> 'Jacques',lastname ->> 'Robin',affiliation ->> ufpe,worksatproject ->> swaip

supervises->> franklinramalho].

Consulta :X:lecturer[name->>'Jacques Robin', supervises->>Y].

X = jacquesrobinY = franklinramalho

F-Logic: generalização de vários F-Logic: generalização de vários formalismos de BD, IA e programação formalismos de BD, IA e programação

F-Logic

Modelode Dados

Relacional:SQL´92

Modelode DadosOrientadoa Objetos:

OQL

ProgramaçãoOrientadaa Objeto:

Java

Representaçãode Conhecimento

com Objetos:Frames,

Redes Semânticas

Representaçãode Conhecimento

com Regras:Sistemas

de Produção,Shell de Sistemas

Especialistas

Representaçãode Conhecimento

com Lógica:Provadoresde Teorema

Modelode DadosObjeto-

Relacional:SQL’99

Modelode DadosDedutivo:Datalog

Programaçãoem Lógica:

Prolog

Representaçãode Conhecimento

com Objetose Lógica:Lógicas

Descritivas

F-Logic e F-Logic e Engenharia Engenharia

de de OntologiasOntologias

Engenhariade Ontologias

Metodologias OO:+ filosofia RUP+ metodologia completa desde requisitos até teste + escalabilidade, reusabilidade, desenvolvimento distribuído+ formalismos e CASE divulgados no mainstream- impedance mismatch entre especificação e implementação para parte comportamental- prototipagem lento- robustez (sem semântica)

Métodos Formais:• filosofia SPIV+ robustez+ metodologia completa desde requisitos até teste - prototipagem lentíssimo -impedance mismatch entre especificação e implementação- escalabilidade- desenvolvimento distribuído- formalismos e CASE não divulgados no mainstream

Programação com Linguagem Declarativa de Alto-Nível:• IA e programação funcional, filosofia RUDE+ prototipagem rápido (desenvolvimento em espiral)+ especificação = implementação- robustez- escalabilidade, reusabilidade, desenvolvimento distribuído- metodologia completa desde requisitos até teste- formalismos e CASE não divulgados no mainstream

F-Logic e F-Logic e Engenharia Engenharia

de de OntologiasOntologias

Orientada a Objetosem F-Logic

Programação em Lógica

Programação com LinguagemDeclarativa de Alto-Nível:+ prototipagem rápido (desenvolvimento em espiral)+ especificação = implementação

Métodos Formais:+ robustez

Metodologias OO:+ metodologia completa desde requisitos até teste + escalabilidade, reusabilidade, desenvolvimento distribuído+ formalismos e CASE divulgados no mainstream

Outras vantagens: Máquinas de inferência built-in para dedução, abdução e indução Programação AutomáticaEstrutural e Comportamentala partir de: modelos UML

Projeto SWAIP exemplos de entrada/saída

Projeto Cigolf (Aprendizagem)

Aplicações de F-LogicAplicações de F-Logic Engenharia de software:

especificação formal executável orientada a objetos Inteligência artificial:

representação do conhecimento por meio de regras e hierarquias conceituais

Banco de dados: BD dedutivas orientada a objetos integração de dados

integração de codificações integração de esquemas integração de BD com modelos de dados diferentes

Web semântica: Agentes inteligentes de processamento de informação na web Dedução automática sobre documentos, objetos e dados na

web

Implementações de F-LogicImplementações de F-Logic Flora:

F-Logic + HiLog + Transaction Logic

Compilador F-Logic para XSB Prolog implementado em Prolog

APIs para Java, C, OBDC, Oracle7, XML

Domínio público, open source Stony Brook University, New York

LoPiX: F-Logic + XPath + XML Implementado em C++, no

entanto sem API C++ Domínio público, executável University of Freiburg, Alemanha

SiRLI: F-Logic com extensões lógicas

(quantificadores existenciais, conectivas)

Implementado em Java Comercial, ontoprise.com

TRIPLE F-Logic + RDF Compilador para Flora Domínio público Stanford/DFKI

Floracle F-Logic + HiLog +

Transaction Logic Compilador para Oracle9i Em desenvolvimento no CIn

Elementos de um programa F-LogicElementos de um programa F-Logic Identificadores de objetos (OID) Átomos-F:

declarações de relações superclasse::subclasse e classe:instância declarações do valor de um atributo/método de um objeto/classe declarações de restrições de tipo de um atributo/método de um

objeto/classe Conjuntos em extensão parcial {...,...} Molécula-F:

agregação de vários átomos-F em uma única expressão apenas uma abreviação sintática

Átomos-P: variação sintática para compatibilidade com Prolog

Termo: Átomo-P ou Molécula F Cláusula lógicas (regras): termo0 :- termo1, ..., termoN. Consultas: cláusula sem conclusão

Identificadores de objetos (OID)Identificadores de objetos (OID)e variáveis lógicase variáveis lógicas

Identificadores de objetos: constantes simbólicas Seguindo convenção de programação em lógica:

constantes começam com letra minúscula e contém nenhum caracter especial além de _

variáveis lógicas começam com letra maiúscula ou _, e podem conter caracteres especiais

Exemplos: OID: o1, o2, isaac, newton, isaacNewton Variáveis lógicas: X, Method, _42

Símbolos funcionais permitem criar: identificadores de objetos compostos, ex, son(jacob)

Átomos-F: hierarquia de classes e Átomos-F: hierarquia de classes e objetos objetos

A hierarquia conceitual de classe e objetos é declarada por átomos-F da forma: subclass::superclass, ou objeto:classeou seja OIDdeObjetoComoClass :: OIDdeObjetoComoClass, e OIDdeObjetoComoObjeto : IODdeObjetoComoClass

Em F-Logic classes são também objetos

Átomos-F: atributos e métodosÁtomos-F: atributos e métodos F-Logic não faz a distinção entre atributos e

métodos: ambos são declarados em átomos-F da forma: objectID[methodName - returnValue] para métodos

(atributos) mono-valorados objectID[methodName - {returnValueSet}] para

métodos (atributos) multi-valorados { } é o operador de agregação em conjunto do F-Logic

Exemplos: o átomo-F isaac[father - abraham] define o valor do

método mono-valorado father do objeto issac o átomo-F abraham[son - {isaac,ismael}] define dois

valores possíveis para método multi-valorado son do objeto abraham

A semântica dos métodos multivalorados é a inclusão de conjuntos não a igualdade

Átomos-F: métodos parametrizadosÁtomos-F: métodos parametrizados Métodos parametrizados são declarados em

átomos-F da forma: objectID[methodName@(ParameterList) - returnValue],

ou objectID[methodName@(ParameterList) - returnValue]

Exemplo: o átomo-F jacob[son@(rachel) - {joseph, benjamin}]

especifica que os objetos joseph e benjamin são dois valores possíveis para o método son do objeto jacob parametrizado pelo objeto rachel

Um parâmetro pode ser um oid ou uma variável lógica

Átomos-F: assinaturas de classes e Átomos-F: assinaturas de classes e restrições de tipos dos métodosrestrições de tipos dos métodos

Restrições de tipos sobre os valores de métodos de classes são especificadas com átomos-F da forma: className[methodName className] className[methodName@(parameterList) className] className[methodName className], ou className[methodName@(parameterList) className]

Exemplos: person[father man]. man[daughter@(woman) woman].

Variáveis lógica em átomos-FVariáveis lógica em átomos-F Variáveis lógicas podem aparecer em qualquer posição

de um átomo-F: posição de nome de classe, C::thing. posição de nome de objeto, X[son@(rachel) - joseph], O:C.

posição de método, jacob[M@(rachel) - joseph], posição de parâmetro de método, jacob[son@(Y) - joseph],

posição de valor de método, jacob[son@(rachel Z). Uso simultâneo de variáveis lógicas em várias posições

permite meta-programação e consultas a meta-dados ex, O[M@(P) - V]

Moléculas-FMoléculas-F Várias átomos-F podem ser agregados e aninhados

em especificações concisas Propriedades conjuntivas são agregadas dentro de []

separadas por ; Propriedades disjuntivas são agregadas dentro de {}

separadas por , () são usadas resolver ambigüidade devido ao

aninhamento Exemplo:

isaac[father - abraham:man[son@(hagar:woman)- ismael]; mother - sarah:woman].

Agregada: isaac[father - abraham]. abraham:man. hagar: woman. abraham[son@(hagar) - ismael]. isaac[mother - sarah]. sarah:woman.

Átomos-P e moléculas-PÁtomos-P e moléculas-P Predicados da programação em lógica pura (Prolog)

podem aparecer em programas F-Logic chamados de átomos-P

Átomos-P permitem: integração com de programas F-Logic com programas Prolog modelagem alternativa

Moléculas-F podem ser aninhadas dentro de átomos-F formando moléculas-P: married(isaac[father - abraham], rebekah:woman).

Átomos-P e moléculas-P não podem ser aninhadas em moléculas-F

Modelagens alternativas Modelagens alternativas com átomos-P e moléculas-Fcom átomos-P e moléculas-F

Modelagem orientado a relações com átomos-P:

married(isaac,rebekah).male(jacob).sonOf(isaac,rebekah,jacob).

Modelagem orientado a objetos com átomos-F:

isaac[married_to - rebekah].jacob:man.isaac[son@(rebekah) -

jacob].

Cláusulas, fatos, regras e programas F-Cláusulas, fatos, regras e programas F-LogicLogic

Cláusulas F-Logic podem ser: uma molécula-F uma molécula-P uma regras com uma molécula (F ou P) em conclusão e uma

conjunção de moléculas (F ou P) como premissas Regras F-Logic são da forma:

headMolecule :- bodyMolecule1, ..., bodyMoleculeN. Fatos F-Logic extendem fatos Prolog com moléculas-

F Regras F-Logic extendem regras Prolog com

moléculas-F na conclusão ou nas premissas Regras F-Logic implementam corpo dos métodos das

classes e objetos Um programas F-Logic é uma conjunção (implícita)

de cláusulas F-Logic

Consultas e expressões de caminhosConsultas e expressões de caminhos Uma consulta F-Logic é uma regra F-Logic sem

conclusão, ou seja, uma conjunção de moléculas (F ou P)

Consultas e premissas das regras podem conter expressões de caminhos usando self (this em Java) e o . da orientação a objetos

Integradas com variáveis lógicas, expressões de caminhos permitem especificar consultas complexas com muita concisão

.. é usado para caminhar sobre métodos multivalorados em grafos de objetos

! e !! são usados para caminhar sobre métodos herdáveis em grafos de objetos

Consultas e expressões de caminhos: Consultas e expressões de caminhos: exemplosexemplos

Consulta F-Logic sem caminho de expressão:

?- isaac[father Y], Y[father X].

Consulta O2SQL:SELECT XFROM X IN managerFROM Y IN X.vehiclesWHERE Y.color = redAND Y.producedBy.city = detroitAND Y.producedBy.president = X

Consultas F-Logic com caminho de expressão:

?- isaac.father[father X].

?- X:manager..vehicles[color red]

.producedBy[city detroit; president X].

HerançaHerança Ambos valores de métodos (objetos) e restrições de

tipos sobre valores de métodos (classes) são herdadas de uma classes para suas subclasses se for declaradas da forma: className[inheritableMethodName objectID], className[inheritableMethodName objectID], className[inheritableMethodName className], ou className[inheritableMethodName className].

F-Logic permite: sobrescrita de valor herdada herança múltipla sobrecarga de métodos

Herança: exemploHerança: exemplogray:color.white:color.elephant[color color].elephant[color gray].royalElephant :: elephant.royalElephant[color white].clyde : elephant.dumbo : royalElephant.

?- clyde[color C].C = gray.?- dumbo[color C].C = white.?- royalElephant[color C].C = white?-

Exemplo introdutório: um BD acadêmicoExemplo introdutório: um BD acadêmicoEsquema: hierarquia de classesempreg::pessoa. prof::empreg. assist::empreg.Esquema: assinatura de classesdepto[nome => string; empregs =>> empreg; chefe => prof].pessoa[nome => string; nasc => data; idade

=> int].empreg[depto => depto; salario => int].publi[nome => string, autores =>>

{assist,prof}].prof[publi =>> publi; titulação *-> PhD; salario -> 50000].assist[publi =>> publi].data[ano=>int; mes=>int; dia=>int].Esquema: regras dedutivasX:pessoa[idade -> I] :- I >= 0, I <= 130. meiaIdade(P) :- P:prof.meiaIdade(P) :- P.idade >= 30, P.idade <= 60.X:[jointPubli@Y->> P] :- X:{prof,assist}, Y:

{prof,assist}, X[publi ->> P], Y[publi ->>P].

E[chefe->C] :- E:empreg, D:depto, E[depto -> D[chefe -> C:empreg].

D:data :- ...

Dadosbob:prof[nome -> “Bob”; nasc -> data[ano => 1960; mes => 01; dia => 02]; depto -> di, publi ->> {jacm,cacm}].mary:prof[nome -> “mary”; titulacao -> mestre depto => di, publi ->> {jacm,cacm}]. phil:assist[nome -> “Phil”, depto => di, publi ->> {cacm}].john:assist[nome -> “John”, depto => di, publi ->> {jacm}].sally:assist[nome -> “Sally”, depto => di, publi ->> {jacm}].jacm:publi[nome -> “JACM”; autores ->> {bob, mary, john, sally}].cacm:publi[nome -> “CAC”, autores ->> {bob, mary, phil}].Consultas?- meiaIdade(E), E:empreg[depto -> di[chefe ->

E]].E = bob.?- mary[jointPubli@E ->> jacm].E = bob, E = john, E = sally

F-Logic como linguagem lógicaF-Logic como linguagem lógicaServiços de dedução: Fundamentação em uma teoria da prova completa e correta Motor de inferência para regras dedutivas com:

referências a objetos nas premissas e conclusões sintaxe de ordem superior semântica da 1a ordem unificação de descrições parciais de objetos

F-Logic como linguagens de consulta e F-Logic como linguagens de consulta e manipulação de BDmanipulação de BD

Serviços fornecidos: Construtores de conjuntos com

semântica de inclusão Operadores de agregação Consultas devolvem todas as

respostas de uma vez Consultas uniforme dos dados e

dos metadados (esquema)

Serviços não fornecidos: Atualizações declarativas Persistência Gerenciamento de grandes

conjuntos de dados Gerenciamento de memória

secundária Gerenciamento de transações

F-Logic como linguagem orientada a F-Logic como linguagem orientada a objetos: serviços fornecidosobjetos: serviços fornecidos

Serviços fornecidos: Identificação única, inclusive

funcionais Construtores de estruturas

complexas ortogonais e extensíveis

Hierarquia de classes (esquema) com herança múltipla de estado e comportamento

Estado inicial e comportamento default

Sobrescrita, sobrecarga e ligação dinâmica

Restrições de tipos

Serviços parcialmente fornecidos:

Completude computacional dependentemente da implementação

Verificação e inferência de tipos indiretamente via regras de ordem superior

Serviços não fornecidos: Encapsulamento Acesso completo a recursos Gerenciamento de versões

F-Logic como linguagem orientada a F-Logic como linguagem orientada a objetos: característicasobjetos: características

Tudo é um objeto: objetos classes atributos valores métodos regras

Não há distinção entre atributos e métodos

Variável lógica pode aparecer em qualquer posição: objetos classes atributos valores métodos regras