Representao do conhecimento hbrida com regras e objetos

Representação do conhecimento híbrida com regras e objetos André Novaes, Bruno Jamir Jacques Robin CIn-UFPE

Roteiro E Motivação da integração regras + objetos E Variedades de integração E JEOPS: um sistema de produção embutido em Java E Flora: uma extensão orientada a objetos de Prolog E Comparação JEOPS X Flora

FRC híbridos regras+objetos: motivação E Pontos fortes dos sistemas baseado em regras E fornece com built-in dedução lógica da 1 a ordem com negação por falha E um mecanismo de inferência poderoso e o mais versátil de todos E com semântica formal E 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 E usam regras que: E são intuitivas e modulares E preservam a verdade (detachment) E pode ser adquiridas por aprendizagem de máquina E Pontos fracos dos sistemas baseado em regras E codificação não intuitiva do conhecimento terminológico e procedimental E quase nenhuma facilidade para estruturação de entidades complexas E limitações das ferramentas e metodologias de desenvolvimento distribuído em larga escala E pouca padronização E poucos serviços computacionais não de IA implementados com regras E interoperabilidade limitada com outras linguagens

FRC híbridos regras+objetos: motivação E Pontos fortes dos sistemas orientado a objetos como FRC E codificação intuitiva do conhecimento terminológico e procedimental E facilidade para estruturação de entidades complexas E ferramentas e metodologias de desenvolvimento distribuído em larga escala consolidadas e muito difundidas E API para os mais variados serviços computacionais e linguagens E ênfase na padronização, interoperabilidade e reuso E Pontos fracos dos sistemas orientado a objetos como FRC E sem máquina de inferência built -in de propósito geral Equalquer mecanismo de inferência além da herança deve ser implementado de zero E parte comportamental codificada de maneira procedimental E ausência da técnicas de aprendizagem de máquina de classes e objetos E semântica formal

FRC híbridos regras+objetos: almejar “o melhor dos 2 mundos” Requisitos Raciocino: • Linguagem declarativa • Predicados com variáveis lógicas • Dedução automática • Semântica formal • Completude computacional Requisitos OO: • Identidade de objetos • Objetos complexos • Classes • Encapsulamento • Herança • Sobrescrita e sobrecarga FRC Híbrido Regras + Objetos

Formalismos de Representação do Conhecimento Híbridos Regras + Objetos Inferência Baseada em Regras Inferência Baseada em Modelagem Orientada a Objetos Frames Sistemas de Produção Linguagem de Programação Orientada a Objetos Programação em Lógicas Descritivas Sistemas de Produção com Frames Sistemas de Produção Embutidos em Linguagem Orientada a Objetos EOOPS Programação em Lógica Orientada a Objetos OOLP Programação em Lógica Descritiva

Formalismos de Representação de Conhecimento Escaláveis e Persistentes Híbridos Regras + Objetos Inferência Baseada em Regras Serviços de Banco de Dados Sistemas de Produção BD Ativos BD Relacional BD Ativos OO BD Objeto. Relacional BD Orientado a Objetos Programação em Lógica BD Dedutivos OO DOOD

Sistema Orientado a Objetos Regras e objetos: como integrar? Hierarquia de Classes Cn Ani: Cnq Mnj: Sistema Baseado em Regras {while. . . do. . . if. . . then. . . else. . . } Base de Regras f 1(. . . , X, . . . ). . . fn(. . . , X, . . . ) f 0(. . . , X, . . . ) Cp Api: Cpk Mpj: f 1(. . . , a, . . . ) fn(. . . , a, . . . ) f 0(. . . , a, . . . ) f 1(. . . , b, . . . ) fn(. . . , c, . . . ) f 0(. . . , d, . . . ) Base de Fatos {while. . . do. . . if. . . then. . . else. . . } Cm Ami: Cmr Mmj: Opi Opmk Omj Api: Opk Ami: Omr Base de Objetos {while. . . do. . . if. . . then. . . else. . . }

Integrar regras com objetos: alternativas sintáticas E Sistema híbrido = sistema orientado a objetos no qual: E métodos procedimentais das classes foram substituídos por E bases de regras encapsuladas E Sistema híbrido = sistema baseado em regras no qual: E instâncias de termos lógicos na base de fatos E foram substituídos por objetos instâncias de uma hierarquia de classes E termos lógicos nas premissas e conclusões das regras E foram substituídos por padrões de objetos com variáveis lógicas no lugar de: E nome de objetos e valores de atributos E possivelmente também nome de classe e atributos

Substituir base de fatos por base de objetos Hierarquia de Classes Cn Ani: Cnq Mnj: Cp Api: Cpk Mpj: Base de Regras f 1(. . . , X, . . . ). . . fn(. . . , X, . . . ) f 0(. . . , X, . . . ) {while. . . do. . . if. . . then. . . else. . . } Cm Ami: Cmr Mmj: Opi Opmk Omj Api: Opk Ami: Omr Base de Objetos {while. . . do. . . if. . . then. . . else. . . }

Substituir métodos procedimentais por bases de regras Hierarquia de Classes Cn Ani: Cnq Mnj: Cp Api: Cpk Mpj: Opi Api: Opk fmj 1(. . . , X, . . . ) . . . fmjn(. . . , X, . . . ) fmn 0(. . . , X, . . . ) fpj 1(. . . , X, . . . ) . . . fpjn(. . . , X, . . . ) fpn 0(. . . , X, . . . ) Cm Ami: Cmr Mmj: Opmk Ami: Omr Omj Base de Objetos Ami: Omr fnj 1(. . . , X, . . . ) . . . fnjn(. . . , X, . . . ) fnn 0(. . . , X, . . . )

Integrar regras com objetos: alternativas de implementação Camada de Regras Linguagem Hóspede Orientada a Objetos CLIPS, RAL/C++, NéOpus, JESS, JEOPS Linguagem de Regras Orientada a Objetos Linguagem de Implementação Orientada a Objetos Lo. Pi. X, Si. LRI Camada Orientada a Objetos Linguagem Hóspede Lógica Flora, Logtalk Linguagem de Regras Orientada a Objetos Linguagem de Implementação Lógica

Sistemas de produção orientados a objetos EOOPS Sistema Ling. Progr. CLIPS C++ - - +/- - RAL/C++ +/- + + - +/- + NéOpus Smalltalk Unif. Resol. Serviços Eficiência Encad. Integr. Conflitos JESS Java - +/- - JEOPS Java + + +/-

Regras JESS E Pode usar classes Java, com restrições class Pessoa { private String nome; private Pessoa pai; . . . } (defclass Pessoa) E Regras com sintaxe própria (lisp-like) (defrule Regra. Avo "O pai do pai de alguém é seu avô” ? a <- (Pessoa (nome ? nome. Avo)) ? p <- (Pessoa (nome ? nome. Pai) (pai ? a)) ? n <- (Pessoa (nome ? nome. Neto) (pai ? p)) => (printout t ? nome. Avo “ é avô de ” ? nome. Neto crlf))

JEOPS: Java Embedded Object-Oriented Production System E Sistema desenvolvido no CIn-UFPE E Base de conhecimento JEOPS: E Parte intencional terminológica: definições de classes Java E Parte extensional: definições de objetos Java E Parte intencional dedutiva: regras de produção onde E cada premissa invoca algum método Java booleano definido em uma classe da parte terminológica da base E cada ação invoca um método Java arbitrário definido em uma classe da parte terminológica da base E Base de fato substituída por base de objetos E Fases de casamento de padrão e de execução de ações incluem herança E Fase de resolução de conflito não modificada (mas poderia se aproveitar da herança)

Lembrete sobre sistemas de produção Base de Regras unificação Base de Fatos Conjunto de Conflito resolução de conflitos Ciclo Regra execução Novos Fatos Obs: para não ter de re-testar a cada ciclo, só testa os fatos modificados (retirados, adicionados)

Casamento de padrão comportamental E Mudança de paradigma E Fatos: Termos Lógicos Objetos E Predicados: Símbolos Lógicos Métodos Booleanos Java E Casamento estrutural Casamento comportamental (pertinência a classes + veracidade dos predicados) p 1, p 2, p 3: Pai(p 1, p 2) Pai(p 2, p 3) Avo(p 1, p 3) Pai(João, José) Pai(José, Marcos) Nome: Marcos Pessoa pai Nome: José Pessoa pai Nome: João Pessoa Regra Avo Para todo objeto p 1, p 2 e p 3 da classe Pessoa, SE p 1. eh. Pai(p 2); p 2. eh. Pai(p 3); ENTÃO

Regras JEOPS 1. Rule : : = "rule" "{" <Rule Body> "}" 2. Rule Body : : = <Declarations> <Local Declarations>? <Conditions> <Actions> 3. Declarations : : = "declarations" (<class name> <ident> (", " <ident>)* )* 4. Local Declarations : : = "localdecl" (<class name> <ident> "=" <expression>)* 5. Conditions : : = "conditions" (<expression>)* 6. Actions : : = (Action)+ 7. Action : : = "assert" "(" <expression> ")" | "retract" "(" <expression> ")" | "modified" "(" <expression> ")" | <block>

JEOPS - Arquitetura Agente assert run objects flush JEOPS Rete Knowledge Base -- - - ---- - - -- Gera entradas Conjunto de Conflito Consulta Base Interna de Regras Base de Objetos Base de Conhecimentos Assert = insere objetos na base de objetos Objects = recupera objetos da base de objetos Flush = limpa base de fatos

JEOPS Compilation. Environment Rule Base JEOPS Rule Base (. rules) Rule Pre-Compiler (. java) JEOPS Esquema de Compilação • Mais simples de implementar • Mais rápido de executar Engine Application JAVA (. java) Compiler Byte. Codes (. class) JAVA JEOPS Runtime. Environment JEOPS Inference Engine

Exemplo ilustrativo: base de conhecimento de planejamento de safári E Motivação: EExemplos clássicos não ficam naturais se resolvidos utilizando Regras + OO E Problema das rainhas E Resolução do fibonacci EExemplo do Wumpus não ilustra bem o problema E Objetos simples sem herança E Sem cálculos matemáticos E Sem casamento de padrões por classes ESolução Modelagem de um novo problema com E Vários objetos E Regras com casamento de padrões por tipos E Herança EProblema: sem profundidade de associação de objetos

Exemplo ilustrativo: base de conhecimento de planejamento de safári E Organizando uma expedição de safári EObjetivos: E Qual animal será a caça? E Em que ambiente será realizado o safári? EVeículo: E Aquático? E Terrestre? ETripulação: E Quantos guias serão necessários? E Quantos caçadores? E Quantos motoristas? EArmas: E Armas de fogo? E Armas brancas?

Base de conhecimento de planejamento de safári: Ontologia UML

Como implementar o safári em JEOPS? E Diagrama de Classes EClasses UML Classes Java ERestrições OCL regras de produção OO E Encadeamento de regras EDetalhamento dos Casos de Uso + Diagrama de seqüências Comportamento do fluxo e chamadas à base de conhecimento E Métodos numéricos EMétodos nas classes Java

Passos de desenvolvimento de uma base de conhecimento JEOPS 1. Definir as classes EAtributos e métodos 2. Definir as regras EInteração entre os objetos da base 3. Voltar ao passo 1 4. Deixar a base de conhecimentos trabalhar. . . 5. Escolher estratégia de resolução de conflito

Exemplo de uso: Safári E Definição das classes EArma, Arma. Fogo, Grupo. Safari, . . . Abstract class Arma { private int preco; private String nome; . . . } class Arma. Fogo extends Arma { private int calibre; private int qtd. Municao; private int preco. Municao; . . . } class Grupo. Safari{ public Vector tripulantes; public Vector pertences; public Vector veiculos; public int financiamento; public int numero. Maximo. Tripulantes; . . . }

Exemplo de uso: Safári E Criação das regras rule Contrata. Guia{ declarations Grupo. Safari g; Guia guia; localdecl conditions g. get. Tripulantes(). size() < g. get. Numero. Maximo. Tripulantes(); g. get. Local(). instance. Of(Local. Terrestre); ((Local. Terrestre) g. get. Local). get. Aberto() == false; g. get. Numero. Guias == 0; actions g. put. Tripulante(guia); modified(g); }

Exemplo de uso: Safári E Criação dos objetos Regras. Safari base = new Regras. Safari(); base. assert(new Animal. Aquatico(“baleia”, "grande", false)); base. assert(new Local. Aquatico. Terrestre("Pântano", "raso", false)); base. assert(new Veiculo. Aquatico("Lancha", 8, new Vector("baixa", "media")); . . . E Execução do motor de inferência base. run();

JEOPS: características interessantes E Pré-compilação de regras E Regras convertidas em classes Java E Extensão de Rete para objetos complexos com herança EAlgoritmo eficiente de casamento de padrão entre fatos e premissa de regra E Estratégias built-in de resolução de conflitos E LRUConflict. Set E MRUConflict. Set E Natural. Conflict. Set E One. Shot. Conflict. Set E Priority. Conflict. Set E KEOPS: E Versão J 2 ME para rodar em dispositivos móveis E Usado para implementar inteligência embutidos em jogos para celulares

JEOPS: aplicações práticas E Agentes de administração de rede E Jogos interativos E Recuperação de informação na web E Música computacional

Flora = Frame Logic + Hi. Log + Transaction Logic + XSB • Organização do conhecimento em hierarquia de classes • Representação de conhecimento taxonômico • Herança múltipla e dinâmica • Uso de processos de desenvolvimento OO Flora • Atualizações na base de fatos • Integrado ao backtrack • Representação de conhecimento procedimental Frame Logic Transaction Logic Hi. Log Compilador Flora Prolog tabelado XSB • • Sintaxe de ordem superior Semântica da 1 a ordem Meta-programação Meta-consultas ao esquema • Terminação garantida em muito mais casos • Cache se sub-provas • Negação por falha com semântica declarativa bem fundamentada

Exemplo de programa Flora Classes: veiculo[capacidade=>integer]. veiculo. Aquatico: : veiculo[profundidade=>>string]. arma. Fogo: : arma[ calibre *=> integer, qtd. Municao *=> integer, preco. Total(integer)*=>integer ]. arma[preco*=>integer, preco. Municao(10)->8, preco. Municao(12)->9]. rifle: : arma. Fogo[calibre*->12, preco*->500]. Instâncias: baleia: animal. Aquatico[porte->grande, perigoso->nao]. bote: veiculo. Aquatico[profundidade->>baixa]. lancha: veiculo. Aquatico[profundidade->>{baixa, media}].

Exemplo de programa Flora Regras A[preco. Total*->P] : - A: : arma. Branca[preco*->P]. X: grupo[armas->>{arpao}] : - X: grupo[animal->baleia]. X[veiculos->>{V}] : comprou. Veiculo, X: grupo. local: local. Aquatico[profundidade->P], V: veiculo. Aquatico[profundidade->>P], btinsert{comprou. Veiculo}. A[preco. Total(Q)*->T] : A: : arma. Fogo[preco*->P, calibre*->C], arma[preco. Municao(C)->PC], T is PC*Q+P. X[armas->>{rifle_ld 1: rifle_longa_dist[qtd. Municao->10], rifle 1: rifle[qtd. Municao->20]}] : X: grupo[animal->_A: animal. Terrestre[porte->T]], T = pequeno, Soma is rifle_longa_dist!preco. Total(10) + rifle!preco. Total(20), preco. Armas. Maximo(PM), Soma < PM.

Exemplo de programa Flora Consultas g 1: grupo[animal->leao]. g 2: grupo[animal->baleia]. ? - G: grupo[armas->>R[qtd. Municao->Y]]. G = g 1 R = rifle 1 Y = 20 R = rifle_ld 1 Y = 10 ? - G: grupo[armas->>R: arma. Branca]. G = g 2 R = arpao ? - G : grupo[animal->A], tnot A[porte->medio]. G = g 2 A = baleia

Sintaxe Legenda: c: classe, o: objeto, m: método, v: valor, p: parâmetro c 1: : c 2 Herança de classes animal. Terrestre: : animal o 1: c 1 Instanciação de Objeto leao: animal. Terrestre c[m=>t] Assinatura de Métodos Univalorados grupo[animal=>animal]. c[m=>>t] Assinatura de Métodos Multivalorados grupo[armas=>>arma]. c[m->v] Métodos Univalorados grupo[animal->leao]. c[m->>{v 1, . . . , vn}] Métodos Multivalorados grupo[armas->>{rifle 1, rifle 2}]. *->> *=>> Métodos que são herdados pelas subclasses/instancias rifle: : arma. Fogo[calibre*->12]. arma. Fogo: : arma[calibre *=> integer]. Agrupando: veiculo. Aquatico: : veiculo[profundidade=>integer, profundidade*->media]. rifle: arma. Fogo[calibre->12, preco->500]. g 1: grupo[animal->X[porte->medio]].

Sintaxe head : -p 1, . . . pn Regra ? - p 1, . . . pn Conculta tnot Negação tabelada X[voa->sim] : - X: ave, tnot X: pinguim. + Negação não tabelada p(X) : - + q(X). X = Z Diferença X[irmao->Y] : X[pai->Z], Y[pai->Z], X = Z. c 1. m 1, c 1!m 1(m. Herdado) Expressão de caminho –método univalorado ? - g 1. animal[porte->X] ? - g 1[animal->A], A[porte->X] o 1. . m 2, Expressão de caminho o 1!!m 2 (m. herdado) -método multivalorado ? - g 1. . arma[preco->X] ? - g 1[arma->>A], A[preco->X] ; ? - a: [porte->medio] ; a: [porte->grande] ou X: grupo[armas->>{arpao}] : X: grupo[animal->baleia].

Sintaxe E Predicados como em Prolog: g 1: grupo[armas->>{a 1, a 2}]. arma_grupo(g 1, a 1). arma_grupo(g 1, a 2). E Permite aninhar objetos em predicados arma_grupo(a 1: arma[preco->100]). E Não permite aninhar predicados dentro de objetos

Consultas Flora X SQL Flora ? - g 1: grupo. animal[porte->X] SQL - Classes create table animal ( id_animal varchar(. . . ), porte varchar(. . . ) ); create table grupo ( id_grupo varchar(. . . ), id_animal varchar(. . . ), ); SQL - Instancias insert into grupo values(. . . ) insert into animal values(. . . ) SQL - Consultas select animal. porte as X from grupo, animal where grupo. id_grupo = g 1 and grupo. id_animal = animal. id_animal

Herança elefante[cor*->cinza]. clyde: elefante[cor->branca]. ? - clyde[cor->X]. X = branca d[m*->e]. d: : b. b[m*->c]. a: b. a: d : - a[m->c]. ? - X[m*->Y]. X=b. Y=c X=d. Y=e ? - X[m->Y]. X=a. Y=c X=a. Y=e

Hi. Log E Sintaxe de alto nivel E Semântica de primeira ordem E Podem aparecer em qualquer lugar onde um simbolo de função apareça E Ex: p(f(x))(a, b, c) , g(f)(g)[m(h(x))->b] E Variaveis podem aparecer em qualquer parte EPermite meta-programação ETodos os metodos univalorados da classe c 1: E ? - c 1[M=>T] ETodas as subclasses de classes com o metodo m: E ? - X: : c 1[m=>_] E Traduzido por predicados apply/N Eclosure(R) (X, Y) apply(closure, R), X, Y)

Transaction Logic E Permite atualização da base de fatos E Representação de conchecimento procedimental E Sintaxe: operacao{literais[|query]} E Non-Backtrackable update EOperações desfeitas quando há backtrack Einsert, insertall, deleteall, eraseall E Backtrackable update EOperações persistem após backtrack E btinsert, btinsertall, btdeleteall, bteraseall E Problemas com tabelamento

Transaction Logic transfer(Amt, Acct 1, Acct 2) : withdrawn(Amt, Acct 1), deposit(Amt, Acct 2). withdrawn(Amt, Acct) : balance(Acct, Bal), Bal >= Amt, Bal 2 is Bal - Amt , change_balance(Acct, Bal 2). deposit(Amt, Acct) : balance(Acct, Bal), Bal 2 is Bal + Amt , change_balance(Acct, Bal 2). change_balance(Acct, Bal 1, Bal 2) : -. . . ? - insert{balance(c 1, 100)}, insert{balance(c 2, 0)}, insert{balance(c 3, 0)}. ? - transfer(100, c 1, c 2), transfer(100, c 1, c 3). ? - balance(c 1, X). Com backtrack Sem backtrack(como em prolog) change_balance(Acct, Bal 1, Bal 2) : btdelete{balance(Acct, Bal 1)}, btinsert{balance(Acct, Bal 2)}. change_balance(Acct, Bal 1, Bal 2) : delete{balance(Acct, Bal 1)}, insert{balance(Acct, Bal 2)}. X = 100. X = 0.

F-Logic: aplicações práticas E Engenharia de software: Eespecificação formal executável orientada a objetos E Inteligência artificial: Erepresentação do conhecimento por meio de regras e hierarquias conceituais E Banco de dados: EBD dedutivas orientada a objetos Eintegração de dados E integração de codificações E integração de esquemas E integração de BD com modelos de dados diferentes E Web semântica: EAgentes inteligentes de processamento de informação na web EDedução automática sobre documentos, objetos e dados na web

Implementações de F-Logic E Flora: E F-Logic + Hi. Log + Transaction Logic E Compilador F-Logic para XSB Prolog implementado em Prolog E Domínio público, open source E Stony Brook University, New York E Lo. Pi. X: E F-Logic + XPath + XML E Implementado em C++, no entanto sem API C++ E Domínio público, executável E University of Freiburg, Alemanha E Si. RLI: E F-Logic com extensões lógicas (quantificadores existenciais, conectivas) E Implementado em Java E Comercial, ontoprise. com E TRIPLE EF-Logic + RDF ECompilador para Flora EDomínio público EStanford/DFKI E Floracle EF-Logic + Hi. Log + Transaction Logic ECompilador para Oracle 9 i EEm desenvolvimento no CIn por mim!

Substituir métodos procedimentais por bases de regras: exemplo (Linguagem Pluto) class person [ address => string; spouse => person; public mary(person); public divorce(); X[mary(Y)] : - X[not spouse -> Z, gender -> G], Y[not spouse -> Z 1], 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[ works. In => dept; salary => integer; public raise(integer); X[raise(Y)] : - S 2 is S 1 + S 2 * Y, del X[sakary ->S 1], ins X[salary -> S 2]] Substituir fatos por objetos: exemplo (Linguagem Flora) person[address => string, spouse => person, mary(person) => void, divorce => void]. employee: : person[works. In => 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]). class dept. X: employee[raise(R: integer), salary -> S] : S 1 is S + R, del(X[salary -> S]), ins(X[salary -> S 1]). tom: employee[works. In -> cpsc, spouse -> pat, salary -> 20000]. cpsc: dept. pat: person[spouse -> tom].

Qual conhecimento codificar nas regras e qual conhecimento codificar nos objetos? E Não existe metodologia estabelecida para fazer tal escolha E 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: E conhecimento dedutivo x conhecimento terminológico E conhecimento declarativo x conhecimento procedimental E Identificar critérios gerais e rigorosos para fazer essas distinções permanece um problema aberto de pesquisa E Conhecimento dedutivo melhor codificado com regras E Conhecimento terminológico melhor codificado com hierarquia de classes E Conhecimento procedimental melhor codificado com métodos

Flora x JEOPS Flora E E E E E Programação em lógica OO Hospedado em Prolog tabelado Sem procedimentos imperativos Sem encapsulamento Unificação estrutural incorporando herança Com semântica formal Encadeamento regressivo Variáveis lógicas em qualquer posição de estruturas de objetos ou classes Fracamente tipada Generaliza modelos de dados relacional, orientado a objetos e objeto-relacional JEOPS E E E E E Sistema de produção OO Hospedado em Java Com procedimentos imperativos Com encapsulamento Casamento de padrões comportamental incorporando herança Sem semântica formal Encadeamento progressivo Variáveis apenas em posição de nome de objeto e valor de atributo Fortemente tipada

Flora x JEOPS Vantagens de Flora E Linguagem multiuso: E especificação formal executável E programação E banco de dados E representação do conhecimento E Semântica formal bem definida E Concisão do código E Expressões de ordem superior para meta-programação e consultas a esquema de BD E Prototipagem rápida de metainterpretadores para: E abdução, indução, resolução de restrições, planejamento e raciocínio bayesiano E Encadeamento regressivo natural para agentes deliberativos E Eficiência Vantagens de JEOPS E Incorporação imediata dos milhares de serviços disponíveis via API Java E Fácil de aprendizagem para larga base de desenvolvedores Java E Encadeamento progressivo natural para agentes reativos

Flora x JEOPS: comparação para safári arma. Fogo: : arma[calibre *=> integer, qtd. Municao *=> integer, preco. Total(integer)*=>integer ]. public class Arma. Fogo extends Arma{ private int calibre; private int quantidade. Municao; private int preco. Municao; public Arma. Fogo(String nome, int preco, int calibre, int quantidade. Municao, int preco. Municao){ super(nome, preco); . . . } public void set. Calibre(int calibre){. . . } public int get. Calibre(){. . . }. . . public int get. Preco. Total(){. . . } rifle: : arma. Fogo[calibre*->12, preco*->500]. public class Rifle extends Arma. Fogo{ public Rifle( String nome, int quantidade. Municao, int preco. Municao){ } } super(nome, 500, 12, quantidade. Municao, preco. Municao);

Flora x JEOPS: comparação para safári baleia: animal. Aquatico[ porte->grande, perigoso->nao ]. lancha: veiculo. Aquatico[ profundidade->>{baixa, media} ]. pantano: local. Aquatico, local. Terrestre[ profundidade->baixa, aberto->nao ]. Animal. Aquatico baleia = new Animal. Aquatico("grande", false); Veiculo. Aquatico lancha = new Veiculo. Aquatico("Lancha", 8, new Vector("baixa", "media") ); Local. Aquatico. Terrestre pantano = new Local. Aquatico. Terrestre( "Pântano", "raso", false);

Flora x JEOPS: comparação para safári X[veiculos->>{V}] : comprou. Veiculo, X: grupo. local: local. Aquatico[profundidade->P], V: veiculo. Aquatico[profundidade->>P], btinsert{comprou. Veiculo}. rule Compra. Veiculo. Aquatico{ declarations Grupo. Safari g; Veiculo. Aquatico embarcacao; conditions g. get. Veiculos(). size()==0; g. get. Local(). instance. Of(Local. Aquatico); embarcacao. get. Profundidades(). contains( ((Local. Aquatico)g. get. Local()). get. Profundidade()); actions g. put. Veiculo(embarcacao); modified(g); }

Flora x JEOPS: comparação para safári A[preco. Total(Q)*->T] : A: : arma. Fogo[ preco*->P, calibre*->C ], arma[preco. Municao(C)->PC], T is PC*Q+P. public int get. Preco. Total(){ int preco = 0; preco = this. get. Preco() + (this. get. Preco. Municao() * this. get. Quantidade. Municao()); return preco; }

Flora x JEOPS: comparação para safári grupo 1[armas->>R[qtd. Municao->Y]] Grupo. Safari grupo = New Grupo. Safari(. . . ); . . . Vector armas = grupo. get. Armas(); Arma arma = null; for(int i; i< armas. size(); i++) { arma = (Arma) armas. get(i); System. out. println(arma. to. String()); }