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

Apresentação em tema: "Representação do conhecimento híbrida com regras e objetos"— Transcrição da apresentação:

1 Representação do conhecimento híbrida com regras e objetos
Jacques Robin CIn-UFPE

2 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

3 FRC híbridos regras+objetos: motivação
Pontos 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 fracos 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

4 FRC híbridos regras+objetos: motivação
Pontos fortes 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 fracos 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

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

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

7 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 BD Ativos OO Sistemas de Produção BD Ativos BD Relacional BD Objeto- Relacional BD Orientado a Objetos BD Dedutivos OO DOOD Programação em Lógica BD Dedutivos

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

9 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

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

11 Substituir métodos procedimentais por bases de regras
Hierarquia de Classes fmj1(...,X,...) ... fmjn(...,X,...)  fmn0(...,X,...) Cn Ani: Cnq Mnj: fpj1(...,X,...) ... fpjn(...,X,...)  fpn0(...,X,...) fnj1(...,X,...) ... fnjn(...,X,...)  fnn0(...,X,...) Cp Api: Cpk Mpj: Cm Ami: Cmr Mmj: Opi Api: Opk Opmk Ami: Omr Omj Ami: Omr Base de Objetos

12 Substituir métodos procedimentais por 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].

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

14 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

15 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

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

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

18 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 {} 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))

19 Regras JESS Pode usar classes Java, com restrições
Regras com sintaxe própria (lisp-like) class Pessoa { private String nome; private Pessoa pai; ... } (defclass Pessoa Pessoa) (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))

20 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 booleano 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)

21 Exemplo de programa JEOPS
Hierarquia de classes class 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)); Regras rule Retranca { declarations Partida p; Jogador a; localdecl Time meuTime = a.getTime(); conditions p.getEtapa() == 2; // Estamos no segundo tempo, ... p.getPlacar(meuTime) >= p.getPlacarAdversario(meuTime); meuTime.getCategoria() < p.getTimeAdversario(meuTime).getCategoria(); // ... e eu sou ruim actions a.vaParaDefesa(); // Então bola pro mato... modified(a); } Execução da máquina de inferência: base.run();

22 JEOPS: características interessantes
Pré-compilação de regras Regras convertidas em classes Java Extensão de Rete para objetos complexos com herança Algoritmo 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

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

24 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

25 Exemplo de programa F-Logic
Hierarquia de classes empreg::pessoa. prof::empreg. assist::empreg. Assinatura de classes depto[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]. Regras D:data :- ... X:pessoa[idade -> I] :- ... meiaIdade(P) :- P:prof. meiaIdade(P) :- P.idade >= 30, P.idade <= 60. 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. ?- ->> jacm]. E = bob, E = john, E = sally ?- ->> P]. P = cacm

26 F-Logic: generalização de vários formalismos de BD, IA e programação
Representação de Conhecimento com Objetos e Lógica: Lógicas Descritivas Modelo de Dados Objeto- Relacional: SQL’99 Modelo de Dados Dedutivo: Datalog Programação em Lógica: Prolog Representação de Conhecimento com Regras: Sistemas de Produção, Shell de Especialistas Modelo de Dados Orientado a Objetos: OQL Representação de Conhecimento com Objetos: Frames, Redes Semânticas Representação de Conhecimento com Lógica: Provadores de Teorema Modelo de Dados Relacional: SQL´92 Programação Orientada a Objeto: Java

27 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 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

28 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 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 

29 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/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

30 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, isaacNewton Variáveis lógicas: X, Method, _42 Símbolos funcionais permitem criar: identificadores de objetos compostos, ex, son(jacob)

31 Átomos-F: hierarquia de classes e objetos
A hierarquia conceitual de classe e objetos é declarada por átomos-F da forma: subclass::superclass, ou objeto:classe ou seja OIDdeObjetoComoClass :: OIDdeObjetoComoClass, e OIDdeObjetoComoObjeto : IODdeObjetoComoClass Em F-Logic classes são também objetos

32 Á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

33 Átomos-F: métodos parametrizados
Métodos parametrizados são declarados em átomos-F da forma: - returnValue], ou - returnValue] Exemplo: o átomo-F - {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

34 Á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] className[methodName  className], ou  className] Exemplos: person[father  man].  woman].

35 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, - joseph], O:C. posição de método, - joseph], posição de parâmetro de método, - joseph], posição de valor de método,  Z). Uso simultâneo de variáveis lógicas em várias posições permite meta-programação e consultas a meta-dados ex, - V]

36 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 - ismael]; mother - sarah:woman]. Agregada: isaac[father - abraham]. abraham:man. hagar: woman. - ismael]. isaac[mother - sarah]. sarah:woman.

37 Á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

38 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. - jacob].

39 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

40 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

41 Consultas e expressões de caminhos: exemplos
Consulta F-Logic sem caminho de expressão: ?- isaac[father  Y], Y[father  X]. Consulta O2SQL: SELECT X FROM X IN manager FROM Y IN X.vehicles WHERE Y.color = red AND Y.producedBy.city = detroit AND 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].

42 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

43 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 ?-

44 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ões sintaxe de ordem superior semântica da 1a ordem unificação de descrições parciais de objetos

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

46 Flora x JEOPS Flora JEOPS 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 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

47 Flora x JEOPS Vantagens de Flora Vantagens de JEOPS
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