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

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

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

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

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

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

11. fpj1(...,X,...) ... fpjn(...,X,...)  fpn0(...,X,...) fnj1(...,X,...) ... fnjn(...,X,...)  fnn0(...,X,...) fmj1(...,X,...) ... fmjn(...,X,...)  fmn0(...,X,...) Cm Cn Cp Ani: Cnq Api: Cpk Ami: Cmr Opi Omj Opmk Mmj: Mnj: Mpj: Api: Opk Ami: Omr Ami: Omr Substituir métodos procedimentaispor bases de regras Hierarquia de Classes 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 Flora, Logtalk CLIPS, RAL/C++, NéOpus, JESS, JEOPS 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. Sistema Ling. Progr. Unif. Integr. Serviços Eficiência Encad. Resol. Conflitos CLIPS C++ - - +/- - RAL/C++ C++ +/- + + - NéOpus Smalltalk + - +/- + JESS Java - +/- +/- - JEOPS Java + + +/- +/- Sistemas de produção orientados a objetos EOOPS

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. 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(); Exemplo de programa JEOPS

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. 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. 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 Exemplo de programa F-Logic

26. F-Logic: generalização de vários formalismos de BD, IA e programação F-Logic 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 Sistemas 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. 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  Implementações de F-Logic

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

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[methodName@(parameterList)  className] • className[methodName  className], ou • className[methodName@(parameterList)  className] • Exemplos: • person[father  man]. • man[daughter@(woman)  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, X[son@(rachel)- joseph], O:C. • posição de método, jacob[M@(rachel)- joseph], • posição de parâmetro de método, jacob[son@(Y)- joseph], • posição de valor de método, jacob[son@(rachel  Z). • Uso simultâneo de variáveis lógicas em várias posições permite meta-programação e consultas a meta-dados • ex, O[M@(P) - V]

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

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. 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]. Modelagens alternativas com átomos-P e moléculas-F

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. 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]. Consultas e expressões de caminhos: exemplos

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. 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 ?- Herança: exemplo

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. Serviços fornecidos: Identificação única, inclusive funcionais Construtores de estruturas complexas ortogonais e extensíveis Hierarquia de classes (esquema) com herança múltipla de estado e comportamento Estado inicial e comportamento default Sobrescrita, sobrecarga e ligação dinâmica Restrições de tipos Serviços parcialmente fornecidos: Completude computacional dependentemente da implementação Verificação e inferência de tipos indiretamente via regras de ordem superior Serviços não fornecidos: Encapsulamento Acesso completo a recursos Gerenciamento de versões F-Logic como linguagem orientada a objetos: serviços fornecidos

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

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