CIn- UFPE Aprendizagem Simbólica Geber Ramalho Jacques Robin Francisco Carvalho CIn-UFPE.
Representação do conhecimento híbrida com regras e objetos Jacques Robin CIn-UFPE.
-
Upload
antonio-leal-corte-real -
Category
Documents
-
view
226 -
download
2
Transcript of Representação do conhecimento híbrida com regras e objetos Jacques Robin CIn-UFPE.
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