Representação do conhecimento híbrida com regras e objetos

Jacques RobinCIn-UFPE

Roteiro

Motivação da integração regras + objetos Variedades de integração JEOPS: um sistema de produção embutido em Java F-Logic: uma extensão orientada a objetos de Prolog

FRC híbridos regras+objetos: motivação

Pontos fortes fortes dos sistemas baseado em regras fornece com built-in dedução lógica da 1a ordem com negação por falha um mecanismo de inferência

poderoso e o mais versátil de todos

com semântica formal que pode também servir de

base para implementação de outros mecanismos como abdução, indução, planejamento, raciocínio não monótono

usam regras que: são intuitivas e modulares preservam a verdade

(detachment) pode ser adquiridas por

aprendizagem de máquina

Pontos fracosfracos dos sistemas baseado em regras codificação não intuitiva do conhecimento terminológico e procedimental

quase nenhuma facilidade para estruturação de entidades complexas

limitações das ferramentas e metodologias de desenvolvimento distribuído em larga escala

pouca padronização poucos serviços computacionais não de IA implementados com regras

interoperabilidade limitada com outras linguagens

FRC híbridos regras+objetos: motivação

Pontos fortesfortes dos sistemas orientado a objetos como FRC codificação intuitiva do conhecimento terminológico e procedimental

facilidade para estruturação de entidades complexas

ferramentas e metodologias de desenvolvimento distribuído em larga escala consolidadas e muito difundidas

API para os mais variados serviços computacionais e linguagens

ênfase na padronização, interoperabilidade e reuso

Pontos fracosfracos dos sistemas orientado a objetos como FRC sem máquina de inferência built-in de propósito geral

qualquer mecanismo de inferência além da herança deve ser implementado de zero

parte comportamental codificada de maneira procedimental

ausência da técnicas de aprendizagem de máquina de classes e objetos

sem semântica formal

FRC híbridos regras+objetos:almejar “o melhor dos 2 mundos”

Requisitos Raciocino:Requisitos Raciocino:• Linguagem declarativa• Predicados com variáveis lógicas• Dedução automática• Semântica formal• Completude computacional

Requisitos OO:Requisitos OO:• Identidade de objetos• Objetos complexos• Classes • Encapsulamento• Herança• Sobrescrita e sobrecarga

FRC Híbrido Regras + FRC Híbrido Regras + ObjetosObjetos

Formalismos de Representação do Conhecimento Híbridos Regras + ObjetosRegras + Objetos

Inferência Baseadaem Regras

Inferência Baseadaem Modelagem

Orientada a Objetos

Sistemas de Produção

Programação em Lógica

Sistemas de ProduçãoEmbutidos em Linguagem

Orientada a ObjetosEOOPS

Programação em LógicaOrientada a Objetos

OOLP

Programação emLógica Descritiva

Sistemas de Produçãocom Frames

Frames

LógicasDescritivas

Linguagem deProgramação

Orientadaa Objetos

Formalismos de Representação de Conhecimento Escaláveis e PersistentesEscaláveis e Persistentes

Híbridos Regras + ObjetosInferência Baseada

em Regras

Sistemas de Produção

Programação em Lógica

BDAtivos

OO

BDDedutivos

OODOOD

Serviços deBanco de Dados

BDRelacional

BDOrientadoa Objetos

BDAtivos

BDDedutivos

BDObjeto-

Relacional

Regras e objetos: como

integrar?Sistema Baseado em Regras

Base de Regrasf1(...,X,...)...fn(...,X,...)

f0(...,X,...)

Base de Fatos

f1(...,a,...) fn(...,a,...) f0(...,a,...)f1(...,b,...) fn(...,c,...) f0(...,d,...)

Sistema Orientado a Objetos

Hierarquia de Classes

CnAni: CnqMnj:

{while ... do ... if ... then ... else ... }

CpApi: CpkMpj:

{while ... do ... if ... then ... else ... }

CmAmi: CmrMmj:

{while ... do ... if ... then ... else ... }

Base de Objetos

OpiApi: Opk

OmjAmi: Omr

OpmkAmi: Omr

Integrar regras com objetos: alternativas sintáticas

Sistema híbrido = sistema orientado a objetos no qual: métodos procedimentais das classes foram substituídos por bases de regras encapsuladas

Sistema híbrido = sistema baseado em regras no qual: instâncias de termos lógicos na base de fatos foram substituídos por objetos instâncias de uma hierarquia de classes

termos lógicos nas premissas e conclusões das regras foram substituídos por padrões de objetos com variáveis lógicas no lugar de: nome de objetos e valores de atributos possivelmente também nome de classe e atributos

Substituirbase de fatos por base de objetos

Base de Regrasf1(...,X,...)...fn(...,X,...)

f0(...,X,...)

Hierarquia de Classes

CnAni: CnqMnj:

{while ... do ... if ... then ... else ... }

CpApi: CpkMpj:

{while ... do ... if ... then ... else ... }

CmAmi: CmrMmj:

{while ... do ... if ... then ... else ... }

Base de Objetos

OpiApi: Opk

OmjAmi: Omr

OpmkAmi: Omr

Substituir métodos procedimentaispor bases de regras

Hierarquia de Classes

CnAni: CnqMnj:

CpApi: CpkMpj:

CmAmi: CmrMmj:

fpj1(...,X,...)...fpjn(...,X,...) fpn0(...,X,...)

fnj1(...,X,...)...fnjn(...,X,...) fnn0(...,X,...)

fmj1(...,X,...)...fmjn(...,X,...) fmn0(...,X,...)

Base de Objetos

OpiApi: Opk

OmjAmi: Omr

OpmkAmi: Omr

Substituir métodos procedimentaispor bases de regras: exemplo

class person [ address => string; spouse => person; public mary(person); public divorce(); X[mary(Y)] :- X[not spouse -> Z, gender ->

G], Y[not spouse -> Z1], not gender -> G], ins X[spouse -> Y], ins Y[spouse -> X]; X[divorce] :- del X[spouse -> Y], del Y[spouse -> X]]

class employee isa person[ worksIn => dept; salary => integer; public raise(integer); X[raise(Y)] :- S2 is S1 + S2 * Y, del X[sakary ->S1], ins X[salary -> S2]]

class dept.

tom:employee[worksIn -> cpsc, spouse -> pat, salary -> 20000].cpsc:dept.pat:person[spouse -> tom].

Substituir fatos por objetos: exemplo

person[address => string, spouse => person, mary(person) => void, divorce =>

void]. employee::person[worksIn => dept, salary => integer, raise(integer) => void].

X:person[mary(Y:person[gender -> Gy]), gender -> Gx] :- not X.spouse, not Y.spouse, Gx =/ Gy,

ins(X[spouse -> Y]), ins(Y[spouse -> X]).

X:person[divorce,spouse -> Y[spouse -> X]] :- del(X[spouse -> Y]), del(Y[spouse -> X]).

X:employee[raise(R:integer), salary -> S] :- S1 is S + R, del(X[salary -> S]), ins(X[salary -> S1]).

tom:employee[worksIn -> cpsc, spouse -> pat, salary -> 20000].cpsc:dept.pat:person[spouse -> tom].

Integrar regras com objetos: alternativas de implementação

Camada de RegrasLinguagem Hóspede Orientada a Objetos

CamadaOrientada a Objetos

Linguagem Hóspede Lógica

Linguagem de RegrasOrientada a Objetos

Linguagem de Implementação Orientada a Objetos

Linguagem de RegrasOrientada a Objetos

Linguagem deImplementação Lógica

LoPiX, SiLRI

CLIPS, RAL/C++, NéOpus, JESS, JEOPS Flora, Logtalk

Problemas da integração regras + objetos: dilema conceitual

Como conciliar declaratividade com encapsulamento? Código de métodos é encapsulado seguindo princípio orientado a

objetos de information-hidding para facilitar manutenção, extendibilidade, escalabilidade, reuso de código e desenvolvimento distribuído por grandes equipes de programadores

No entanto, chamada de métodos com código encapsulado em premissas e/ou conclusões de regras destrói a declaratividade das regras

Porque? O código encapsulado pode ter efeitos colaterais invisíveis a partir das regras e que podem modificar a base de fatos e de regras

Permanece um problema aberto de pesquisa em linguagens híbridas regras e objetos

Sistemas atuais sacrificam um para preservar o outro

Problemas da integração regras + objetos: dilema metodológico

Qual conhecimento codificar nas regras e qual conhecimento codificar nos objetos? Não existe metodologia estabelecida para fazer tal escolha Com a experiência da codificação de bases de conhecimento

em domínio diversos, o engenheiro do conhecimento desenvolve intuição para distinguir entre: conhecimento dedutivo x conhecimento terminológico conhecimento declarativo x conhecimento procedimental

Identificar critérios gerais e rigorosos para fazer essas distinções permanece um problema aberto de pesquisa

Conhecimento dedutivo melhor codificado com regras Conhecimento terminológico melhor codificado com hierarquia

de classes Conhecimento procedimental melhor codificado com métodos

Sistemas de produção orientados a objetos EOOPS

CLIPS

RAL/C++

NéOpus

JESS

JEOPS

Sistema Ling.Progr.

C++

C++

Smalltalk

Java

Java

Unif.Integr.

-

+/-

+

-

+

Serviços

-

+

-

+/-

+

Eficiência

+/-

+

+/-

+/-

+/-

Encad. Resol.Conflitos

-

-

+

-

+/-

Regras CLIPS

Nem todos objetos são utilizados

As regras tem sintaxe própria (lisp-like)

(defclass Pessoa (is-a USER) (role concrete) (pattern-match reactive) (slot nome (create-accessor read-write)) (slot pai (create-accessor read-write)))

(defrule RegraAvo "O pai do pai de alguém é seu avô” ?a <- (object (is-a Pessoa) (nome ?nomeAvo)) ?p <- (object (is-a Pessoa) (nome ?nomePai) (pai ?a)) (object (is-a Pessoa) (nome ?nomeNeto) (pai ?p)) => (printout t ?nomeAvo “ é avô de ” ?nomeNeto crlf))

RegraAvo { // O pai do pai de alguém é seu avô Avo (PessoaMT nome::NomeAvo) Pai (PessoaMT nome::NomePai pai==Avo) Neto (PessoaMT nome::nomeNeto pai==Pai)--> printf(“%s é avô de %s\n”, NomeAvo, NomeNeto))

Regras RAL/C++

Utiliza classes C++, se indicado

Sintaxe um pouco mais próxima à de C++

class Pessoa { public: char nome[20]; Pessoa pai; ...}wmedef PessoaMT:Pessoa {}

Regras JESS

Pode usar classes Java, com restrições

Regras com sintaxe própria (lisp-like)(defrule RegraAvo "O pai do pai de alguém é seu avô” ?a <- (Pessoa (nome ?nomeAvo)) ?p <- (Pessoa (nome ?nomePai) (pai ?a)) ?n <- (Pessoa (nome ?nomeNeto) (pai ?p))=> (printout t ?nomeAvo “ é avô de ” ?nomeNeto crlf))

class Pessoa { private String nome; private Pessoa pai; ...}(defclass Pessoa Pessoa)

JEOPS: Java Embedded Object-Oriented Production System

Sistema desenvolvido no CIn-UFPE Base de conhecimento JEOPS:

Parte estática terminológica: definições de classes Java Parte dinâmica: definições de objetos Java Parte estática dedutiva: regras de produção onde

cada premissa invoca algum método Java booleanobooleano definido em uma classe da parte terminológica da base

cada ação invoca um método Java arbitrário definido em uma classe da parte terminológica da base

Base de fato substituída por base de objetos Fases de casamento de padrão e de execução de

ações incluem herança Fase de resolução de conflito não modificada (mas

poderia se aproveitar da herança)

Exemplo de programa JEOPS Hierarquia de classesclass Jogador { private Time time; private int habilidade; ... }class Time { private Jogador[] jogs; ... }class Partida { private int etapa; private int tempo; ...}class Goleiro extends Jogador {...}class Meia extends Jogador {...}class Atacante extends Jogador {...}

Objetos (fatos):RegrasFutebol base = new RegrasFutebol();Time camaroes = new Time(“Camaroes”);base.assert(camaroes);base.assert(new Goleiro(camaroes, “MBoma”));base.assert(new Lateral(camaroes, “Mfede”));base.assert(new Meia(camaroes, “Kanu”));base.assert(new Atacante(camaroes, “Wome”));...base.assert(new Partida(brasil, camaroes));

Regrasrulerule Retranca { declarationsdeclarations Partida p; Jogador a; localdecllocaldecl Time meuTime = a.getTime(); conditionsconditions p.getEtapa() == 2; // Estamos no segundo tempo, ... p.getPlacar(meuTime) >= p.getPlacarAdversario(meuTime); meuTime.getCategoria() < p.getTimeAdversario(meuTime).getCategoria(); // ... e eu sou ruim actionsactions a.vaParaDefesa(); // Então bola pro mato... modified(a);}

Execução da máquina de inferência:base.run();

JEOPS: características interessantes

Pré-compilação de regras Regras convertidas em classes Java

Extensão de Rete para objetos complexos com herançaAlgoritmo eficiente de casamento de padrão entre fatos e premissa de regra

Estratégias built-in de resolução de conflitos LRUConflictSet MRUConflictSet NaturalConflictSet OneShotConflictSet PriorityConflictSet

KEOPS: Versão J2ME para rodar em dispositivos móveis Usado para implementar inteligência embutidos em jogos poara celulares

JEOPS: aplicações práticas

Agentes de administração de rede Jogos interativos Recuperação de informação na web Música computacional

Frame Logic (F-Logic)

Base de conhecimento F-Logic: Parte estática terminológica: definições de classes Parte dinâmica: definições de objetos instâncias dessas classes

Parte estática dedutiva: clausulas de Horn onde cada premissa e cada conclusão é uma definição de objeto com

variáveis lógicas no lugar de alguns elementos Base de fatos substituída por base de objetos Unificação de variáveis lógica inclui herança Implementações diferentes usam busca diferentes:

LoPiX encadeia as regras para frente com busca em largura Flora encadeia as regras para trás com busca em profundidade tornada segura pelo uso da memoização

Exemplo de programa F-LogicHierarquia de classesempreg::pessoa. prof::empreg. assist::empreg.

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

RegrasD:data :- ... X:pessoa[idade -> I] :- ...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].

Objetos (fatos):bob: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?- mary[jointPubli@phil ->> P].P = cacm

F-Logic: generalização de vários 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: aplicações práticas 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 objetosintegraçã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 webDedução automática sobre documentos, objetos e dados na web

Implementaçõ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

TRIPLEF-Logic + RDFCompilador para FloraDomínio públicoStanford/DFKI

FloracleF-Logic + HiLog + Transaction Logic

Compilador para Oracle9iEm desenvolvimento no CIn

Elementos 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/classedeclaraçõ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ãoapenas 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)e 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, isaacNewtonVariáveis lógicas: X, Method, _42

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

Átomos-F: hierarquia de classes e objetos

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

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

Á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

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 restriçõ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], ouclassName[methodName@(parameterList) className]

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

Variá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-dadosex, O[M@(P) - V]

Molé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

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 Prologmodelagem 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 com á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-Logic

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

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ç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: exemplo

gray: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?-

F-Logic como linguagem lógica

Serviç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õessintaxe de ordem superiorsemântica da 1a ordemunificação de descrições parciais de objetos

F-Logic como linguagem orientada a objetos: 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

Flora Programação em lógica OO Hospedado em PrologProlog tabelado Sem procedimentosSem procedimentos imperativos Sem encapsulamentoSem encapsulamento Unificação estruturalestrutural

incorporando herança Com semântica Com semântica formal Encadeamento regressivoregressivo Variáveis lógicas em qualquer

posição de estruturas de objetos ou classes

FracamenteFracamente tipada Generaliza modelos de dados

relacional, orientado a objetos e objeto-relacional

JEOPS Sistema de produção OO Hospedado em JavaJava Com procedimentosCom procedimentos imperativos Com encapsulamentoCom encapsulamento Casamento de padrões

comportamentalcomportamental incorporando herança

Sem semântica Sem semântica formal Encadeamento progressivoprogressivo Variáveis apenas em posição de

nome de objeto e valor de atributo

FortementeFortemente tipada

Flora x JEOPS

Vantagens de Flora Linguagem multiuso:

especificação formal executável programação banco de dados representação do conhecimento

Semântica formal bem definida Concisão do código Expressões de ordem superior

para meta-programação e consultas a esquema de BD

Prototipagem rápida de meta-interpretadores para: abdução, indução, resolução de restrições, planejamento e raciocínio bayesiano

Encadeamento regressivo natural para agentes deliberativos

Eficiência

Vantagens de JEOPS Incorporação imediata dos

milhares de serviços disponíveis via API Java

Fácil de aprendizagem para larga base de desenvolvedores Java

Encadeamento progressivo natural para agentes reativos

Flora x JEOPS