Você está na página 1de 19

27/10/2017 Google Tradutor

OWL 2 e SWRL Tutorial


Martin Kuba , Instituto de Ciência da Computação, makub@ics.muni.cz

© 2012

Esta página explica a Web Ontology


Language OWL 2 para nós que são
visualmente orientados. Também mostra
como usar uma ontologia OWL com
regras SWRL a partir do código Java ao
chamar um razoável.

Observe que esta página descreve o


OWL versão 2, que só pode ser
processada por ferramentas projetadas
para essa versão, como Protege 4, OWL
API 3 ou Pellet 2. As ferramentas
projetadas para o OWL versão 1 mais
antiga, como o Protege 3, não
funcionarão com os exemplos.

Conteúdo
Ontologia
Tipos de axiomas
Declarações
Asserção de classe
Asserção de subclasse
Asserção de propriedade
Asserção de anotação
Axiomas da propriedade
Cadeias de propriedade
Expressões de classe
Definir operações
Enumeração
Complemento e interseção
União
Quantificação Existencial
Restrição de valor individual
Quantificação universal
Restrições de tipo de dados
Regras SWRL
Diferentes indivíduos e chaves
Usando OWL + SWLC ontologia e razão do código Java
Predicados SWRL
SWRL regula com expressões de classe
SWRL regula com restrições de intervalo de dados
SWRL regula com o núcleo incorporado
Regras SWRL com built-ins personalizados
SWRL regula com built-ins personalizados para indivíduos
Dicas, truques e conspirações
Domínios e intervalos de propriedade
Propriedades Reflexivas
Negação
Pedido parcial
Limites de OWL2 e SWRL

Ontologia de OWL
A ontologia OWL é um conjunto de axiomas , que fornecem asserções lógicas explícitas sobre três tipos de coisas
- classes , indivíduos e propriedades . Ao usar um pedaço de software chamado raciocínio , podemos inferir outros fatos implicitamente contidos
na ontologia, por exemplo, se um indivíduo Martin estiver estudante em sala de aula e a classe Estudante é uma subclasse da classe Pessoa, um
razoável irá inferir que Martin é uma pessoa.

Existem duas categorias de propriedades em ontologias OWL.Propriedades de dados são relações binárias que ligam um indivíduo a um pedaço
de dados digitados, como um xsd: dateTime ou xsd: literal de cadeia. As propriedades dos objetos são relações binárias que ligam um indivíduo a
um indivíduo.

Há muitas maneiras como uma ontologia de OWL pode ser escrita , no entanto, o importante é o significado da ontologia, que pode ser mostrado em
uma imagem. Eu uso aqui as imagens Ontograf produzidas pelo editor Protege OWL . Por exemplo, aqui está uma pequena ontologia com duas
classes e um indivíduo, que possui uma propriedade de dados:

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 1/19
27/10/2017 Google Tradutor

O mesmo axioma pode ser escrito de várias maneiras. O mais comum é o formato XML / RDF, a especificação OWL 2 usa o formato de sintaxe
funcional , os autores do Protege desenvolveram um formato Manchester mais curto e o formato mais conciso é Turtle. Eu usarei o formato de
sintaxe funcional neste tutorial e, em alguns casos, mostrar-se-ei também a sintaxe de Manchester quando for mais compreensível.

Tipos de axiomas
Existem muitos tipos de axiomas que podem ser expressos em OWL 2. Vamos listá-los aqui.

Declarações
A declaração de classe define uma classe. Uma classe pode conter indivíduos.

Declaração (Classe (: Pessoa))

Declaração individual define um indivíduo nomeado.

Declaração (NamedIndividual (: Martin))

Asserção de classe afirma que um indivíduo pertence a uma classe:

ClassAssertion (: Estudante: Martin)

A afirmação da subclasse declara que todos os indivíduos que pertencem a uma classe pertencem também a outra classe.

SubClassOf (: Aluno: Pessoa)

Declaração de propriedade define uma propriedade de dados para vincular um indivíduo a dados ou propriedade de objeto para vincular a um
indivíduo:

Declaração (DataProperty (: hasEmail))

Declaração (ObjectProperty (: hasSpouse))

A afirmação da propriedade afirma a relação de um indivíduo com um dado ou indivíduo:

DataPropertyAssertion (: hasEmail: Martin "makub@ics.muni.cz" ^^ x

ObjectPropertyAssertion (: hasSpouse: Martin: Lenka)

Asserção de propriedade negativa afirma que a relação de um indivíduo com um dado ou indivíduo não existe . OWL usa Open World
Assumption, então, se um indivíduo não estiver vinculado por algum imóvel com algum valor, ele pode ser causado por dois motivos - ou ele
realmente não possui a propriedade com o valor, ou é desconhecido porque as informações faltam no ontologia. Uma afirmação de propriedade
negativa afirma que o indivíduo não pode ter esse valor de propriedade.

NegativeObjectPropertyAssertion (: hasSpouse: Martin: Peter)


NegativeDataPropertyAssertion (: hasEmail: Martin "president@whitehouse.gov")

A afirmação de anotação permite anotar qualquer coisa com alguns detalhes, por exemplo, podemos usar o ICS como o nome de um indivíduo
porque é uma abreviatura e usar a anotação para rotular a abreviatura com o significado completo "Instituto de Ciência da Computação". As

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 2/19
27/10/2017 Google Tradutor
imagens geradas por Protege mostram o rótulo em vez do nome.

Declaração (NamedIndividual (: MU))


AnnotationAssertion (rdfs: rótulo: MU "Masaryk University")

Declaração (NamedIndividual (: ICS))


AnnotationAssertion (rdfs: label: ICS "Institute of Computer Science")

Declaração (NamedIndividual (: SC))


AnnotationAssertion (rdfs: rótulo: SC "Supercomputing Center")

Axiomas da propriedade
Podemos definir muitas coisas sobre as propriedades (veja a Sintaxe OWL 2 - Axiomas de propriedades de objetos e OWL2 Semântica direta -
Axiomas de expressão de propriedades de objetos para detalhes), que uma propriedade
é transitiva , simétrica , assimétrica, reflexiva , irreflexiva e funcional (pode ter apenas um valor ), inverso-funcional (é inverso é
funcional), inverso a alguma outra propriedade, subpropriedade de alguma outra propriedade, equivalente a alguma outra propriedade,
ou disjunta com alguma outra propriedade (dois indivíduos não podem ser vinculados por ambas as propriedades ao mesmo tempo) .

Em um exemplo simples, podemos definir que a propriedade temSpouse é simétrica , funcional e irreflexiva :

SymmetricObjectProperty (: hasSpouse)
FunctionalObjectProperty (: hasSpouse)
IrreflexiveObjectProperty (: hasSpouse)

Em um exemplo mais elaborado, na imagem a seguir, uma nova propriedade transitiva é definida como PartOf , que conecta as partes
organizacionais da Universidade Masaryk. Então, a propriedade hasPart é definida como uma propriedade inversa para isPartOf .

Declaração (ObjectProperty (: isPartOf)


TransitiveObjectProperty (: isPartOf)

ObjectPropertyAssertion (: isPartOf: SC
ObjectPropertyAssertion (: isPartOf: IC

Declaração (ObjectProperty (: hasPart))


InverseObjectProperties (: hasPart: isP

Agora, podemos usar um raciocínio para inferir as outras propriedades. Como o isPartOf é transitivo, SCB isPartOf MU e porque hasPart é inverso
a isPartOf, obtemos as relações inferidas completas:

ObjectPropertyAssertion (: isPartO
ObjectPropertyAssertion (: hasPart
ObjectPropertyAssertion (: hasPart
ObjectPropertyAssertion (: hasPart

Mostra o poder do raciocínio - não temos que declarar todas as relações, apenas o mínimo necessário, e o resto pode ser inferido.

Cadeias de propriedade

A versão 2 da OWL introduziu importantes características novas - propriedades encadeadas . Eles permitem definir algumas relações entre três
indivíduos, o exemplo mais proeminente é o tio da propriedade que pode ser definido como a cadeia de propriedades do pai e do irmão .

Uma propriedade pode ser acorrentada mesmo com ela própria. Por exemplo, podemos definir a propriedade isEmployedAt , que é uma cadeia
própria e a propriedade transitiva isPartOf , o que significa que, se uma pessoa estiver implantada em alguma unidade organizacional, a pessoa
também é empregada nas unidades organizacionais maiores.

Declaração (ObjectProperty (: isEmployedAt))

ObjectPropertyAssertion (: isEmployedAt: Martin: SC)

SubObjectPropertyOf (ObjectPropertyChain (: isEmployedAt: isPartOf):

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 3/19
27/10/2017 Google Tradutor

Novamente, usando um raciocínio, podemos inferir as relações completas:

ObjectPropertyAssertion (: isEmployedAt: Martin: ICS)


ObjectPropertyAssertion (: isEmployedAt: Martin: MU)

Expressões de classe
As classes podem ser definidas usando expressões de classe .(Para obter detalhes, consulte Sintaxe OWL 2 - Expressões de classee OWL 2
Semântica direta - Axiomas de expressão de classe .) Uma definição de classe comum é uma afirmação de que uma classe chamada
é equivalente a alguma classe (não nomeada / anônima) definida por uma expressão. As classes também podem ser definidas
como disjoined com outra classe, o que significa que elas não compartilham nenhum indivíduo.

Set operações: enumeração, união, interseção, complemento

OWL 2 fornece set operações em seu significado matemático usual.

Vamos mostrar as operações do conjunto em um exemplo. Podemos definir uma nova classe Criança que contenha quatro novos indivíduos
denominados SmallBoy, BigBoy, SmallGirl, BigGirl . Esses indivíduos devem ser declarados como diferentes uns dos outros, caso contrário, um
raciocínio OWL espera que eles possam ser os mesmos:

Declaração (Classe (: Criança))


Declaração (NamedIndividual (: BigBoy))
Declaração (NamedIndividual (: BigGirl))
Declaração (NamedIndividual (: SmallBoy))
Declaração (NamedIndividual (: SmallGirl))
ClassAssertion (: Criança: BigBoy)
ClassAssertion (: Criança: BigGirl)
ClassAssertion (: Criança: SmallBoy)
ClassAssertion (: Child: SmallGirl)
DifferentIndividuals (: BigBoy: BigGirl: SmallBoy: SmallGirl)

Enumeração

Vamos definir duas classes básicas, enumerando seus membros, a classe Boy contendo meninos e a classe Small contendo crianças pequenas. Ou
seja, o SmallBoy individual é tanto em Boy quanto em classes pequenas. Aqui, a sintaxe funcional não é tão agradável quanto a sintaxe de
Manchester usada no editor Protege OWL, então ambas as sintaxes são mostradas:

Sin

Cl
sintaxe funcional:

SubClassOf (: Menino: Criança)


SubClassOf (: Pequeno: Criança)
EquivalentClasses (: Boy ObjectOneOf (: SmallBoy: BigBoy))
Cl
EquivalentClasses (: Small ObjectOneOf (: SmallBoy: SmallGirl))

Complemento e interseção

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 4/19
27/10/2017 Google Tradutor
Agora, podemos definir uma nova classe Girl como uma classe que é a interseção da classe Child com uma classe sem nome que é
o complemento da classe Boy . Esta é uma descrição um pouco complicada, o mesmo é mais intuitivo no formato Protege / Manchester, onde a
classe Girl é equivalente a Child and not Boy , ou seja, uma garota é uma criança que não é um menino.

Com essa definição, um razoável descobrirá que a classe Girl contém os indivíduos SmallGirl e BigGirl.

sintaxe funcional:

Declaração (Classe (: Menina))


SubClassOf (: Girl: Child)
EquivalentClasses (: Girl ObjectIntersectionOf (ObjectCompl

Sintaxe de proteção:

Classe: menina
SubClassOf:
Criança
Equivalente a:
Criança e (não (Menino))

União

Podemos definir uma nova classe Boy_or_small como a união das classes Small and Boy . Novamente, a descrição é mais intuitiva na sintaxe
Protege como Boy ou Small . Um razoável descobrirá que a classe contém os indivíduos SmallBoy, SmallGirl, BigBoy :

sintaxe funcional:

Declaração (Classe (: Boy_or_Small))


EquivalentClasses (: Boy_or_Small ObjectUnionOf (: Sm

Sintaxe de proteção:

Classe: Boy_or_Small
Equivalente a:
Garoto
ou pequeno

Quantificação Existencial

Uma expressão de classe pode dizer que a classe contém apenas indivíduos que estão conectados por uma determinada propriedade com
indivíduos de uma determinada classe. Vamos mostrar isso com um exemplo. Podemos definir uma nova OrgUnit de classe que contenha os três
indivíduos MU, ICS, SC.

Declaração (Classe (: OrgUnit))


ClassAssertion (: OrgUnit: ICS)
ClassAssertion (: OrgUnit: MU)
ClassAssertion (: OrgUnit: SC)

Então, podemos definir um novo Empregado de classe como uma subclasse de Pessoa , que é equivalente a uma classe anônima de indivíduos
que estão vinculados pela propriedade isEmployedAt a indivíduos da classe OrgUnit . O significado é que os funcionários são as pessoas que estão
empregadas em algum lugar:

sintaxe funcional:

Declaração (Classe (: Empregado))


SubClassOf (: Empregado: Pessoa)
EquivalentClasses (: Employee ObjectSomeValuesFrom (: isEmplo

Sintaxe de proteção:

Classe: Empregado
SubClassOf:
Pessoa
Equivalente a:
isEmployedAt Some OrgUnit

Ao usar um raciocínio, podemos inferir que o empregado da classe contém o Martin individual. O raciocínio pode até produzir uma explicação para
isso:

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 5/19
27/10/2017 Google Tradutor

Restrição de Valor Individual

Uma expressão de classe também pode dizer que a classe contém indivíduos que estão conectados por uma determinada propriedade com
um determinado indivíduo .

No nosso exemplo, podemos definir uma nova classe EmployeesOfMU como contendo indivíduos que estão conectados pela
propriedade isEmployedAt com MU individual, ou seja, aqueles que estão empregados em MU. Um razoável descobrirá que a classe contém
o Martin particular.

sintaxe funcional:

Declaração (Classe (: EmployeesOfMU))


SubClassOf (: EmployeesOfMU: Pessoa)
EquivalentClasses (: EmployeesOfMU ObjectHasValue (:

Sintaxe de proteção:

Classe: EmployeesOfMU
SubClassOf:
Pessoa
Equivalente a:
isEmployedAt value MU

Quantificação universal

A quantificação universal (em matemática conhecida pelo operador ∀) em OWL é um pouco estranha devido à suposição do mundo aberto que o
OWL tem.

A quantificação existencial descrita acima (OWL operator ObjectSomeValuesFrom() ), conforme definido em OWL 2 Direct Semantics, afirma
"indivíduos tais que existe algum indivíduo da classe dada conectada pela propriedade dada", na notação matemática ObjectSomeValuesFrom (OPE
CE): {x | ∃ y: (x, y) ∈ (OPE) OP e y ∈ (CE) C } onde OPE denota uma expressão de propriedade do objeto,. OP é função de interpretação de
propriedade do objeto, CE denota uma expressão de classe,. C é função de interpretação de classe.

A quantificação universal é definida como o operador ObjectAllValuesFrom (OPE CE): {x | ∀ y: (x, y) ∈ (OPE) OP implica y ∈ (CE) C }, o que significa
que os indivíduos são sempre conectados pela propriedade dada somente aos indivíduos da classe dada .

O problema com o pressuposto do mundo aberto é que, no mundo aberto, uma ontologia pode não conter todas as informações. Por exemplo,
imagine uma ontologia que afirma que o indivíduo Pedro tem dois filhos, filhos, João e Paulo. Podemos definir uma classe ManWhoHaveOnlySons
como a classe de indivíduos que estão conectados pela propriedade hasChild apenas a indivíduos da classe Menino , ou seja, ObjectAllValuesFrom
(: hasChild: Boy). No entanto, o indivíduo Peter não está necessariamente na classe, porque Peter também pode ter uma filha Jane, apenas a
ontologia não contém essa informação.

A quantificação universal na OWL funciona apenas em conjunto com as restrições de cardinalidade , de modo que se sabemos que um indivíduo
pode ser conectado por uma determinada propriedade ao máximo de alguns indivíduos diferentes, e nós conhecemos todos os indivíduos, então
uma conclusão pode ser extraída.

É um pouco difícil encontrar um exemplo na vida real, mas aqui está um. Cada pessoa tem no máximo dois pais. Digamos que se ambos os pais
são da mesma nacionalidade, então a pessoa tem a mesma nacionalidade.

Vamos criar um novo Ivan , que está conectado por uma nova propriedade de objeto hasParent aos indivíduos Martin e Lenka . O significado é que
Ivan é filho de Martin e Lenka.

Declaração (NamedIndividual (: Ivan))


ClassAssertion (: Pessoa: Ivan)
Declaração (ObjectProperty (: hasParent
ObjectPropertyAssertion (: hasParent: Iv
ObjectPropertyAssertion (: hasParent: Iv

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 6/19
27/10/2017 Google Tradutor
Podemos afirmar que uma Pessoa tem no máximo dois pais e definir uma nova classe checa contendo Martin e Lenka . O importante novo são os
últimos dois axiomas - a quantificação universal de que os indivíduos que têm todos os pais checos são (uma subclasse de) tchecos e que todos os
indivíduos nomeados em nossa ontologia são diferentes:

SubClassOf (: Person ObjectMaxCardinality (2: hasParent))

Declaração (Classe (: Checa))


SubClassOf (: Checo: Pessoa)
ClassAssertion (: Checa: Lenka)
ClassAssertion (: Czech: Martin)

SubClassOf (ObjectAllValuesFrom (: hasParent: Czech): Czech)


DifferentIndividuals (: BigBoy: BigGirl: ICS: Ivan: Lenka: MU: Martin: SC: SmallBoy: SmallGirl)

Com esses axiomas, a conclusão feita por um raciocínio é - Ivan está na classe checa . Ele é uma Pessoa, então ele pode ter no máximo dois pais,
ele tem dois pais que são indivíduos diferentes, e ambos são checos. Assim, não há mais pais para ele, e o quantificador universal pode ser
satisfeito - ele tem apenas pais checos.

Restrições de tipo de dados

Para propriedades de dados, podemos restringir os valores de uma propriedade de dados. Por exemplo, o axioma

EquivalentClasses (: Person DataExactCardinality (1: hasAge DatatypeRestriction (xsd: integer xsd: minInclusive "0" ^^ xsd: inteiro xsd: maxInclusi

ou na sintaxe de Manchester

Classe: Pessoa
Equivalente a:
hasAge exatamente 1 xsd: integer [> = 0, <= 130]

define que indivíduos na classe Pessoa têm exatamente um valor da propriedade hasAge que é um número inteiro no intervalo entre 0 e 130.

Regras SWRL

O idioma OWL 2 não é capaz de expressar todas as relações. Um exemplo conhecido é que não pode expressar a relação filho de pais casados ,
porque não há nenhuma maneira na OWL 2 para expressar a relação entre indivíduos com os quais um indivíduo tem relações.

A expressividade do OWL pode ser ampliada adicionando regras SWRL ( linguagem de regras da Web semântica ) a uma ontologia. As regras
SWRL são semelhantes às regras nos idiomas Prolog ou DATALOG. De fato, as regras SWRL são regras DATALOG com predicados unários para
descrever classes e tipos de dados, predicados binários para propriedades e alguns predicados n-ary incorporados especiais. (Consulte a
seção SWRL predicados para detalhes)

O editor Protege OWL suporta regras SWRL, e os argumentos Pellet e Hermit também suportam regras SWRL.

Vamos reutilizar nosso exemplo de Ivan, o filho de Martin e Lenka. A propriedade simétrica tem uma ligação entre Martin e Lenka.

SymmetricObjectProperty (: hasSpouse)
ObjectPropertyAssertion (: hasSpouse: M
ObjectPropertyAssertion (: hasParent: Iv
ObjectPropertyAssertion (: hasParent: Iv

Podemos adicionar uma regra SWRL dizendo que um X individual da classe Pessoa, que tem pais Y e Z, de forma que Y tenha cônjuge Z, pertence
a uma nova classe ChildOfMarriedParents . Essa regra é melhor descrita na sintaxe Protege:

Pessoa (? X), hasParent (? X,? Y), hasParent (? X,? Z), hasSpouse (? Y,? Z) -> ChildOfMarriedParents (? X)

Também pode ser descrito na sintaxe funcional:

Prefixo (var: = <urn: swrl #>)

Declaração (Classe (: ChildOfMarriedParents))


SubClassOf (: ChildOfMarriedParents: Pessoa)

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 7/19
27/10/2017 Google Tradutor

DLSafeRule (
Corpo(
ClassAtom (: Pessoa variável (var: x))
ObjectPropertyAtom (: hasParent Variable (var: x) Variável (var: y))
ObjectPropertyAtom (: hasParent Variável (var: x) Variável (var: z))
ObjectPropertyAtom (: hasSpouse Variável (var: y) Variável (var: z))
)
Cabeça(
ClassAtom (: ChildOfMarriedParents Variable (var: x))
)
)

Quando usamos o raciocínio Pellet ou Hermit que suporta as regras SWRL, infere que Ivan pertence à classe ChildOfMarriedParents e até explica
por que:

ClassAssertion (: ChildOfMarriedParents: Ivan)

Diferentes indivíduos e chaves


O pressuposto do mundo aberto da OWL diz que uma ontologia pode não conter todas as informações e, portanto, algumas informações podem
ser desconhecidas. É por isso que os indivíduosnomeados com nomes diferentes podem representar o mesmo indivíduo, a menos que seja
explicitamente afirmado que eles são diferentes. É também por isso que precisamos especificar nos exemplos acima (as operações definidas e a
quantificação universal) que os indivíduos são diferentes.

Podemos declarar os indivíduos nomeados diferentes de duas maneiras. Um é pelo axioma DifferentIndividual ():

DifferentIndividuals (: BigBoy: BigGirl: SmallBoy: SmallGirl: ICS: MU: SC: Ivan: Lenka: Martin)

No entanto, desta forma, é conhecido por causar problemas de desempenho para o motivo quando o número de indivíduos é grande.A segunda
maneira de tornar os indivíduos diferentes é usar uma propriedade de dados funcional com valores exclusivos. A propriedade funcional pode ter
apenas um valor, e assim torna os indivíduos diferentes quando seus valores são diferentes. Se a propriedade também é declarada como
uma chave , torna os indivíduos com o mesmo valor para ser o mesmo indivíduo.

Declaração (DataProperty (: hasId))


FunctionalDataProperty (: hasId)
HasKey (: Person () (: hasId))
DataPropertyAssertion (: hasId: Lenka "1234")
DataPropertyAssertion (: hasId: Martin "5648")

Usando a ontologia OWL e o razoável do código Java


Uma ontologia não tem muito valor se não for usada. Felizmente, já existem ferramentas para usar uma ontologia em seu código de
programação. Recomendo usar as seguintes ferramentas:

OWL API é a API Java usada pelo editor Protege OWL


Pellet 2.2 reasoner, que possui suporte para regras SWRL. (Por favor, use a versão 2.2, porque o Pellet 2.3 possui um erro que faz com que
ele seja suspenso neste exemplo.)

Preparei um projeto Maven que contém todas as fontes deste exemplo, dependências na API OWL do repositório Maven Central e Pellet 2.2
do Berkeley BOP Maven Repository . O projeto Maven pode ser compilado e usado a partir de uma linha de comando ou de um ambiente de
desenvolvimento integrado como IntelliJ IDEA, Eclipse ou NetBeans.

Atualização 2015-02-25: OWL API mudou para https://github.com/owlcs/owlapi/ e o Protege 5 está usando o OWL API 4 mais recente

Atualização 2016-05-06: atualizei os exemplos de código no repositório gitHub para API OWL 4.2.3

Clone o repositório Git https://github.com/martin-kuba/owl2-swrl-tutorial .

Existem exemplos de como usar a API OWL , no entanto, eu mostro aqui o meu:

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 8/19
27/10/2017 Google Tradutor

pacote cz.makub;

importa com.clarkparsia.owlapi.explanation.DefaultExplanationGenerator;
importar com.clarkparsia.owlapi.explanation.util.SilentExplanationProgressMonitor;
import com.clarkparsia.pellet.owlapiv3.PelletReasonerFactory;
importar org.semanticweb.owlapi.apibinding.OWLManager;
importar org.semanticweb.owlapi.io.OWLObjectRenderer;
importar org.semanticweb.owlapi.model. *;
importar org.semanticweb.owlapi.reasoner.OWLReasoner;
importar org.semanticweb.owlapi.reasoner.OWLReasonerFactory;
importar org.semanticweb.owlapi.reasoner.SimpleConfiguration;
importar org.semanticweb.owlapi.vocab.OWLRDFVocabulário;
importar org.semanticweb.owlapi.vocab.PrefixOWLOntologyFormat;
importe uk.ac.manchester.cs.bhig.util.Tree;
importe uk.ac.manchester.cs.owl.explanation.ordering.ExplanationOrderer;
importe uk.ac.manchester.cs.owl.explanation.ordering.ExplanationOrdererImpl;
importe uk.ac.manchester.cs.owl.explanation.ordering.ExplanationTree;
importe uk.ac.manchester.cs.owlapi.dlsyntax.DLSyntaxObjectRenderer;

importar java.util. *;

/ **
* Exemplo de Como usar Uma ontologia OWL com hum Razoável.
*
<code> mvn compile; * Executar em Maven com <code> mvn compile; mvn exec: java -Dexec.mainClass = cz.makub.Tutorial </ code>
*
@author Martin Kuba makub@ics.muni.cz * @author Martin Kuba makub@ics.muni.cz
* /
Tutorial de classe pública {

private static final String BASE_URL = "http://acrab.ics.muni.cz/ontologies/tutorial.owl" ;


renderizador OWLObjectRenderer estático privado = novo DLSyntaxObjectRenderer ();

public static void main (String [] args) lança OWLOntologyCreationException {

// prepara a ontologia e o raciocínio


gerente OWLOntologyManager = OWLManager.createOWLOntologyManager ();
OWLOntology ontologia = manager.loadOntologyFromOntologyDocument (IRI.create (BASE_URL));
OWLReasonerFactory reasonerFactory = PelletReasonerFactory.getInstance ();
new SimpleConfiguration()); OWLReasoner reasoner = reasonerFactory.createReasoner (ontologia, Nova SimpleConfiguration ());
fábrica OWLDataFactory = manager.getOWLDataFactory ();
PrefixOWLOntologyFormat pm = (PrefixOWLOntologyFormat) manager.getOntologyFormat (ontologia);
"#" ); pm.setDefaultPrefix (BASE_URL + "#" );

// recebe classe e seus indivíduos


":Person" , pm); OWLClass personClass = factory.getOWLClass ( ": Pessoa" , pm);

para (OWLNamedIndividual pessoa: reasoner.getInstances (personClass, false ) .getFlattened ()) {


"person : " + renderer.render(person)); System.out.println ( "pessoa:" + renderer.render (pessoa));
}

// obtenha um determinado indivíduo


":Martin" , pm); OWLNamedIndividual martin = factory.getOWLNamedIndividual ( ": Martin" , pm);

// obter valores das propriedades selecionadas no indivíduo


":hasEmail" , pm); OWLDataProperty hasEmailProperty = factory.getOWLDataProperty ( ": hasEmail" , pm);

":isEmployedAt" , pm); OWLObjectProperty isEmployedAtProperty = factory.getOWLObjectProperty ( ": isEmployedAt" , pm);

para (OWLLiteral email: reasoner.getDataPropertyValues (martin, hasEmailProperty)) {


"Martin has email: " + email.getLiteral()); System.out.println ( "Martin TEM e-mail:" + email.getLiteral ());
}

para (OWLNamedIndividual ind: reasoner.getObjectPropertyValues (martin, isEmployedAtProperty) .getFlattened ()) {


"Martin is employed at: " + renderer.render(ind)); System.out.println ( "Martin E Empregado em:" + renderer.render (ind));
}

// obtenha rótulos
new LocalizedAnnotationSelector(ontology, factory, "en" , "cs" ); Como LocalizedAnnotationSelector = novo LocalizedAnnotationSelector (ontologia,
para (OWLNamedIndividual ind: reasoner.getObjectPropertyValues (martin, isEmployedAtProperty) .getFlattened ()) {
"Martin is employed at: '" + as.getLabel(ind) + "'" ); System.out.println ( "Martin E Empregado em: '" + as.getLabel (ind) + "' );
}

// é inverso de uma propriedade, ou seja, quais indivíduos estão em relação com um determinado indivíduo
":MU" , pm); Universidade OWLNamedIndividual = factory.getOWLNamedIndividual ( ": MU" , pm);
OWLObjectPropertyExpression inverso = factory.getOWLObjectInverseOf (isEmployedAtProperty);
para (OWLNamedIndividual ind: reasoner.getObjectPropertyValues (universidade, inversa) .getFlattened ()) {
"MU inverseOf(isEmployedAt) -> " + renderer.render(ind)); System.out.println ( "MU inverseOf (isEmployedAt) ->" + renderer.render (ind));
}

// descobrir quais classes o indivíduo pertence


DeFina <OWLClassExpression> assertedClasses = martin.getTypes (ontologia);
para (OWLClass c: reasoner.getTypes (martin, false ) .getFlattened ()) {
boolean asserted = assertedClasses.contains (c);
"asserted" : "inferred" ) + " class for Martin: " + renderer.render(c)); System.out.println (? (Afirmado "Afirmado" : "inferido" ) + "classe pa
}

// lista todos os valores da propriedade do objeto para o indivíduo


Mapa <OWLObjectPropertyExpression, Definir <OWLIndividual >> assertedValues = martin.getObjectPropertyValues (ontologia);
para (OWLObjectProperty objProp: ontology.getObjectPropertiesInSignature ( true )) {
para (OWLNamedIndividual ind: reasoner.getObjectPropertyValues (martin, objProp) .getFlattened ()) {
boolean asserted = assertedValues.get (objProp). contém (ind);
"asserted" : "inferred" ) + " object property for Martin: " ? System.out.println ((afirmado "Afirmado" : "inferido" ) + "Propriedade fazer obje
" -> " + renderer.render(ind)); + Renderer.render (objProp) + "->" + renderer.render (ind));
}
}

// lista todos os mesmos indivíduos


para (OWLNamedIndividual ind: reasoner.getSameIndividuals (martin)) {
"same as Martin: " + renderer.render(ind)); System.out.println ( "mesmo que Martin:" + renderer.render (ind));
}

// pergunte ao razoável se Martin está empregado em MU

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 9/19
27/10/2017 Google Tradutor
resultado booleano = reasoner.isEntailed (factory.getOWLObjectPropertyAssertionAxiom (isEmployedAtProperty, martin, university));
"Is Martin employed at MU ? : " + result); System.out.println ( "Martin E Empregado em MU:" + resultado);

// verifique se a regra SWRL é usada


":Ivan" , pm); OWLNamedIndividual ivan = factory.getOWLNamedIndividual ( ": Ivan" , pm);
":ChildOfMarriedParents" , pm); OWLClass chOMPClass = factory.getOWLClass ( ": ChildOfMarriedParents" , pm);
OWLClassAssertionAxiom axiomToExplain = factory.getOWLClassAssertionAxiom (chOMPClass, Ivan);
"Is Ivan child of married parents ? : " + reasoner.isEntailed(axiomToExplain)); System.out.println ( "Ivan é filho de pais casados ?:" + Reasoner

// explique por que Ivan é filho de pais casados


DefaultExplanationGenerator explanationGenerator =
novo DefaultExplanationGenerator (
new SilentExplanationProgressMonitor()); Gerente, reasonerFactory, ontologia, reasoner , Novo SilentExplanationProgressMonitor ());
Definir <OWLAxiom> explicação = explicaçãoGenerator.getExplanation (axiomToExplain);
new ExplanationOrdererImpl(manager); ExplicaçãoOrderer deo = novo ExplicaçãoOrdererImpl (gerente);
ExplicaçãoTree explainTree = deo.getOrderedExplanation (axiomToExplain, explicar);
System.out.printlnl ();
"-- explanation why Ivan is in class ChildOfMarriedParents --" ); System.out.println ( "- explicação Por Que Ivan Está na Classe ChildOfMarriedPare
"" ); printIndented (explainTree, "" );
}

private static void printIndented (Tree <OWLAxiom> nó, String indent) {


OWLAxiom axioma = node.getUserObject ();
System.out.printlnl (travessão + renderer.render (axioma));
se (! node.isLeaf ()) {
para (Árvore <OWLAxiom> filho: node.getChildren ()) {
" " ); printIndented (Criança, Recuo + "" );
}
}
}

/ **
* Aula de Ajuda para extrair Rótulos, Comentários e Outras Anotações em Línguas Preferidas.
* Seleciona a Primeira anotação literal Que corresponde AOS idiomas fornecidos na dada Ordem.
* /
classe estática pública LocalizedAnnotationSelector {
final particular Lista <String> langs;
ontologia de OWLOntology final privada ;
fábrica final de OWLDataFactory final ;

/ **
* Construtor.
*
@param ontology ontology * Ontologia ontologia de Parâmetros
@param factory data factory * Fábrica de Dados de fábrica @param
@param langs list of prefered languages; * @param langs Lista de idiomas-preferido; Se não for fornecido, o Locale.getDefault () é usado
* /
public LocalizedAnnotationSelector (OWLOntology ontology, fábrica de OWLDataFactory, String ... langs) {
este .langs = (langs == null )? Arrays.asList (Locale.getDefault (). ToString ()): Arrays.asList (langs);
esta .ontologia = ontologia;
esta .factory = fábrica;
}

/ **
* Fornece O Primeiro Rótulo não Correspondente Primeiro idioma.
*
@param ind individual * @ Param ind indivíduo
@return label in one of preferred languages or null if not available * @ Retomar o Rótulo em hum dos idiomas preferenciais OU nulo se Não estiver
* /
public String getLabel (OWLNamedIndividual ind) {
retornar getAnnotationString (ind, OWLRDFVocabulary.RDFS_LABEL.getIRI ());
}

"UnusedDeclaration" ) @SuppressWarnings ( "UnusedDeclaration" )


public String getComment (OWLNamedIndividual ind) {
retornar getAnnotationString (ind, OWLRDFVocabulary.RDFS_COMMENT.getIRI ());
}

public String getAnnotationString (OWLNamedIndividual ind, IRI annotationIRI) {


retornar getLocalizedString (ind.getAnnotations (ontology, factory.getOWLAnnotationProperty (annotationIRI)));
}

Private String getLocalizedString (Definir anotações <OWLAnnotation>) {


new ArrayList<OWLLiteral>(annotations.size()); Lista <OWLLiteral> literalLabels = nova ArrayList <OWLLiteral> (anotações.size ());
para (rótulo OWLAnnotation: anotações) {
se (label.getValue () instância de OWLLiteral) {
literalLabels.add ((OWLLiteral) label.getValue ());
}
}
para (String lang: langs) {
para (OWLLiteral literal: literalLabels) {
se (literal.hasLang (lang)) retornar literal.getLiteral ();
}
}
para (OWLLiteral literal: literalLabels) {
se (! literal.hasLang ()) retornar literal.getLiteral ();
}
retorno nulo ;
}
}
}

Saída do programa:

pessoa: BigBoy
pessoa: Lenka
pessoa: SmallGirl
pessoa: SmallBoy
pessoa: Martin
pessoa: Ivan

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 10/19
27/10/2017 Google Tradutor
pessoa: BigGirl
Martin tem email: makub@ics.muni.cz
Martin está empregado em: ICS
Martin está empregado em: SC
Martin trabalha em: MU
Martin está empregado em: 'Institute of Computer Science'
Martin está empregado em: 'Supercomputing Center'
Martin é empregado em: 'Masaryk University'
MU inverseOf (isEmployedAt) -> Martin
classe inferida para Martin: ⊤
classe afirmada para Martin: checa
Classe inferida para Martin: EmployeesOfMU
Classe inferida para Martin: Pessoa
classe afirmada para Martin: Student
Classe inferida para Martin: Empregado
propriedade de objeto afirmada para Martin: hasSpouse -> Lenka
propriedade de objeto inferida para Martin: isEmployedAt -> ICS
propriedade de objeto afirmada para Martin: isEmployedAt -> SC
propriedade de objeto inferida para Martin: isEmployedAt -> MU
o mesmo que Martin: Martin
Martin trabalha na MU? : verdade
Ivan é filho de pais casados? : verdade

- explicação por que Ivan está na classe ChildOfMarriedParents -


ChildOfMarriedParents (Ivan)
Pessoa (Ivan)
hasParent (Ivan, Martin)
hasParent (Ivan, Lenka)
hasSpouse (Martin, Lenka)
ChildOfMarriedParents (? X) ← Pessoa (? X) ⋀ hasParent (? X,? Y) ⋀ hasParent (? X,? Z) ⋀ hasSpouse (? Y,? Z)

Predicados SWRL
As regras SWRL podem usar outros predicados do que apenas nomes de classe ou propriedade. Os predicados podem ser

expressões de classe - expressões de classe arbitrárias, não apenas classes nomeadas


expressões de propriedade - o único operador disponível no OWL 2 para criar expressões de propriedade é inverso da propriedade do
objeto, no entanto, o mesmo efeito pode ser conseguido trocando os argumentos da propriedade, portanto, não há necessidade de usar as
expressões de propriedade em SWRL
restrições do intervalo de dados - especifica o tipo de valor de dados, como inteiro, data, união de alguns tipos de esquema XML, tipo
enumerado
Individuais individuais e diferentes - para especificar sama e diferentes indivíduos
built-ins core SWRL - predicados especiais definidos na proposta SWRL que podem manipular valores de dados, por exemplo, para adicionar
números
Customized SWRL built-ins - você pode definir seus próprios built-ins usando o código Java

Vamos mostrar isso com um exemplo. Uma ontologia simples com regras está disponível em swrl_tutorial.owl . Define três indivíduos com seus

aniversários:

Declaração (Classe (: Pessoa))


Declaração (ObjectProperty (: hasChild))
Declaração (Classe (: Pais))
Declaração (Classe (: Adulto))
SubClassOf (: Adulto: Pessoa)
SubClassOf (: pai: pessoa)
Declaração (DataProperty (: bornOnDate))
Declaração (DataProperty (: bornInYear))
Declaração (DataProperty (: hasAge))
FunctionalDataProperty (: hasAge)
Declaração (DataProperty (: hasDriverAge))

Declaração (NamedIndividual (: Martin))


ClassAssertion (: Pessoa: Martin)
DataPropertyAssertion (: bornOnDate: Martin "1972-10-02" ^^ xsd: data)

Declaração (NamedIndividual (: Lenka))


ClassAssertion (: Pessoa: Lenka)
DataPropertyAssertion (: bornOnDate: Lenka "1975-11-10" ^^ xsd: date)

Declaração (NamedIndividual (: Ivan))


ClassAssertion (: Pessoa: Ivan)
DataPropertyAssertion (: bornOnDate: Ivan "2006-04-14" ^^ xsd: date)

ObjectPropertyAssertion (: hasChild: Martin: Ivan)

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 11/19
27/10/2017 Google Tradutor
ObjectPropertyAssertion (: hasChild: Lenka: Ivan)

A ontologia também define algumas regras:

(Por favor, note que no Protege 4.1 o editor de regras SWRL está quebrado, então essas regras não foram criadas em Protege, elas foram escritas
em um editor de texto editando diretamente o código fonte da ontologia. A ontologia swrl_tutorial.owl está escrita em sintaxe funcional que Protege
4.1 pode carregar diretamente.)

Há um pequeno inconveniente quando se trabalha com regras SWRL, que sua sintaxe humana não está bem padronizada. A imagem acima é uma
captura de tela do Protege 4.1, que torna as regras em uma variante da sintaxe de Manchester sem qualificadores de espaço para nome.

SWRL regula com expressões de classe


A regra na lista exibida como

Pessoa (? X), hasChild min 1 Pessoa (? X) -> Pais (? X)

está na sintaxe funcional (definida em A Sintaxe para Regras em OWL2 ) escrito como

DLSafeRule (
Anotação (rdfs: comentário "Regra com expressão de classe")
Corpo(
ClassAtom (: Pessoa variável (var: x))
ClassAtom (
ObjectMinCardinality (1: hasChild: Person)
Variável (var: x)
)
)
Cabeça(
ClassAtom (: Variável pai (var: x))
)
)

Seu significado é que os indivíduos, que estão na classe Pessoa, eque tenham pelo menos uma propriedade temChild com um indivíduo da classe
Pessoa, devem estar na classe Parent. Ou em outras palavras, que as pessoas com pelo menos uma criança são pais.

Quando você usa o motivo Pellet, que suporta as regras SWRL, ele irá inferir que Martin e Lenka estão na classe Parent, como pode ser visto na
seguinte imagem no canto inferior direito:

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 12/19
27/10/2017 Google Tradutor

Quando você clica no ponto de interrogação (?) No direito da informação inferida, o raciocínio até fornece informações sobre como essas

informações foram inferidas:

Observe que você sempre pode criar uma nova classe chamada equivalente a uma expressão de classe e usar a classe nomeada em vez da
expressão da classe.

Observe também que, neste exemplo particular, não há necessidade de usar uma regra SWRL, o mesmo pode ser modelado simplesmente
definindo a classe Parent como subclasse da expressão de classe "(hasChild min 1 Person)" em OWL. Ou tornando-o equivalente à expressão da
classe, que é uma afirmação mais forte. As regras SWRL são realmente necessárias apenas para modelar estruturas não-árvore que não podem ser
modeladas em OWL.

SWRL regula com restrições de intervalo de dados


A seguinte regra usa uma restrição de intervalo de dados:

Pessoa (? P), número inteiro [> = 18, <= 65] (? Idade), hasAge (? P,? Age) -> hasDriverAge (? P, true)

A restrição do intervalo de dados é satisfeita quando a variável "age" tem um valor inteiro entre 18 e 65 inclusive.

Este exemplo mostra uma restrição de intervalo de dados complexa com facetas , um exemplo mais simples seria integer(?x) ou xsd:date(?
y) que restringem o tipo sem usar facetas.

Para obter uma descrição completa dos intervalos de dados, consulte o intervalo de dados de OWL 2 . Um exemplo de intervalo de dados usando
união, interseção, complemento e facetas no mesmo tempo seria na sintaxe de Manchester:

((número inteiro [> = 1, <= 2] ou inteiro [> 5, <7]) e não ({0})) (? y)

e o mesmo na sintaxe funcional:

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 13/19
27/10/2017 Google Tradutor

DataRangeAtom (
DataIntersectionOf (
DataUnionOf (
DatatypeRestriction (xsd: integer xsd: minInclusive "1" ^^ xsd: integer xsd: maxInclusive "2" ^^ xsd: integer)
DatatypeRestriction (xsd: integer xsd: minExclusive "5" ^^ xsd: inteiro xsd: maxExclusive "7" ^^ xsd: integer)
)
DataComplementOf (
DataOneOf ("0" ^^ xsd: inteiro)
)
)
Variável (var: y)
)

SWRL regula com o núcleo incorporado


A proposta SWRL define também alguns predicados especiais, que podem ser usados para manipular valores de dados. Os predicados são
chamados de built-ins do núcleo SWRL e são identificados pelos IRIs no namespace swlrb:. Apenas o raciocinómetro de Pellet, desde o momento
da escrita, os suporta, e não é compatível com todos eles (veja quais os conjuntos de SWRL que o Pellet oferece suporte para detalhes).

As seguintes regras da listagem usam o núcleo incorporado, elas seriam escritas com a maior precisão como:

Pessoa (? P), hasAge (? P,? Age), swrlb: greaterThan (? Age, 18) -> Adulto (? P)
Pessoa (? P), bornOnDate (? P,? Data), xsd: data (? Date), swrlb: data (? Data,? Ano,? Mês,? Dia,? Zona horária? -> bornInYear (? P,? ano)

A primeira dessas duas regras diz que pessoas com idade superior a 18 são adultos. A segunda regra leva o valor de dados da propriedade
bornOnDate, que deve ser de xsd: tipo de data, divide-a em pedaços e adiciona a parte ano como o valor da propriedade bornInYear para a mesma
pessoa.

Quando o motivo é usado, a segunda regra é usada:

Há algumas restrições no uso de built-ins. No raciocínio Pellet, eles podem ser usados apenas no corpo de uma regra, não na cabeça. E eles podem
ser usados apenas para valores de dados, não para valores de objeto. Alguns built-ins, como o swrlb: date (), podem ser usados com variáveis
vinculadas e não vinculadas, enquanto outros, como o swrlb: greaterThan (), podem ser usados apenas para variáveis vinculadas.

Regras SWRL com built-ins personalizados

Você pode até definir seus próprios built-ins SWRL. A partir do momento da escrita, apenas o raciocínio Pellet permite isso. Existe alguma
documentação antiga enganosa em SWRLBuiltInBridge que foi escrita para o SWRLTab disponível apenas no Protege 3 antigo que não suporta o
OWL2, mas não é utilizável no Protege 4.1 mais novo ou em programas Java usando o OWL API 3 mais recente.

Graças ao Como estender o suporte de regras SWRL da Pellet2.2.2 com o seu built-in personalizado? na página eu encontrei como definir meus
próprios built-ins personalizados para uso com OWL API 3.

A regra

Pessoa (? P), nascido no ano (? P,? Ano), my: thisYear (? Nowyear), swrlb: subtrair (? Age,? Nowyear,? Year) -> hasAge (? P,? Age)

usa o my: thisYear custom built-in para vincular o valor inteiro do ano atual à variável "nowyear" e, em seguida, usa o núcleo swrlb: subtrair
incorporado para calcular a idade da pessoa em anos, então define o resultado como o valor da propriedade hasAge. A regra pode ser usada em um
programa Java:

pacote cz.makub;

importar aterm.ATermAppl;
import com.clarkparsia.pellet.owlapiv3.PelletReasonerFactory;
importar com.clarkparsia.pellet.rules.builtins.BuiltInRegistry;
importa com.clarkparsia.pellet.rules.builtins.GeneralFunction;
importa com.clarkparsia.pellet.rules.builtins.GeneralFunctionBuiltIn;
importar org.mindswap.pellet.ABox;
importar org.mindswap.pellet.Literal;
importar org.mindswap.pellet.utils.ATermUtils;
importar org.semanticweb.owlapi.apibinding.OWLManager;
importar org.semanticweb.owlapi.io.OWLObjectRenderer;
importar org.semanticweb.owlapi.model. *;
importar org.semanticweb.owlapi.reasoner.OWLReasoner;
importar org.semanticweb.owlapi.reasoner.OWLReasonerFactory;
importar org.semanticweb.owlapi.reasoner.SimpleConfiguration;
importar org.semanticweb.owlapi.vocab.PrefixOWLOntologyFormat;
importe uk.ac.manchester.cs.owlapi.dlsyntax.DLSyntaxObjectRenderer;

importar java.text.SimpleDateFormat;
importar java.util.Calendar;
importar java.util.Map;
https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 14/19
27/10/2017 Google Tradutor
importar java.util.Set;

Importar org.mindswap.flast.utils.Namespaces.XSD estático ;

/ **
* Exemplo de Pellet costume SWRL embutido.
*
<code> mvn exec:java -Dexec.mainClass=cz.makub.SWRLBuiltInsTutorial </code> * Executar em Maven com <code> mvn exec: java -Dexec.mainClass = cz.ma
*
@author Martin Kuba makub@ics.muni.cz * @author Martin Kuba makub@ics.muni.cz
* /
classe pública SWRLBuiltInsTutorial {

/ **
* Implementação de hum SWRL custom-built-in.
* /
classe estática privada ThisYear implementa GeneralFunction {

booleano público aplicar (ABox abox, Literal [] args) {


Calendário = Calendar.getInstance ();
new SimpleDateFormat( "yyyy" ).format(calendar.getTime()); Ano String = new SimpleDateFormat ( "aaaa" ) .format (calendar.getTime ());
se (args [ 0 ] == null ) {
// variável não vinculada, preencha com o ano atual
0 ] = abox.addLiteral(ATermUtils.makeTypedLiteral(year, XSD + "integer" )); args [ 0 ] = abox.addLiteral (ATermUtils.makeTypedLiteral (ano, XSD +
retornar args [ 0 ]! = null ;
else { } Else {
// variável é vinculada, compare seu valor com o ano atual
return year.equals (args [ 0 ] .getLexicalValue ());
}
}

public boolean isApplicable ( boolean [] boundPositions) {


// o built-in é aplicável apenas para um argumento
return boundPositions.length == 1 ;
}

private static final String DOC_URL = "http://acrab.ics.muni.cz/ontologies/swrl_tutorial.owl" ;

public static void main (String [] args) lança OWLOntologyCreationException {


// registre meu built-in
"urn:makub:builtIn#thisYear" , new GeneralFunctionBuiltIn( new ThisYear())); BuiltInRegistry.instance.registerBuiltIn ( "urn: makub: BuiltIn # this
// inicializar ontologia e razão
gerente OWLOntologyManager = OWLManager.createOWLOntologyManager ();
OWLOntology ontologia = manager.loadOntologyFromOntologyDocument (IRI.create (DOC_URL));
OWLReasonerFactory reasonerFactory = PelletReasonerFactory.getInstance ();
new SimpleConfiguration()); OWLReasoner reasoner = reasonerFactory.createReasoner (ontologia, Nova SimpleConfiguration ());
fábrica OWLDataFactory = manager.getOWLDataFactory ();
PrefixOWLOntologyFormat pm = manager.getOntologyFormat (ontologia) .asPrefixOWLOntologyFormat ();
// use a regra com o built-in para inferir valores de propriedade de dados
":Martin" , pm); OWLNamedIndividual martin = factory.getOWLNamedIndividual ( ": Martin" , pm);
listAllDataPropertyValues (Martin, ontologia, reasoner);

":Ivan" , pm); OWLNamedIndividual ivan = factory.getOWLNamedIndividual ( ": Ivan" , pm);


listAllDataPropertyValues (ivan, ontologia, reasoner);
}

public static void listAllDataPropertyValues (OWLNamedIndividual individual, OWLOntology ontology, OWLReasoner reasoner) {
new DLSyntaxObjectRenderer(); OWLObjectRenderer renderizador = Novo DLSyntaxObjectRenderer ();
Mapa <OWLDataPropertyExpression, Definir <OWLLiteral >> assertedValues = individual.getDataPropertyValues (ontologia);
para (OWLDataProperty dataProp: ontology.getDataPropertiesInSignature ( true )) {
para (OWLLiteral literal: reasoner.getDataPropertyValues (individual, dataProp)) {
DeFina <OWLLiteral> literalSet = assertedValues.get (dataProp);
boolean asserted = (literalSet! = null && literalSet.contains (literal));
"asserted" : "inferred" ) + " data property for " +renderer.render(individual)+ " : " System.out.println ((afirmado? "Afirmado" : "inferida" ) +
" -> " + renderer.render(literal)); + Renderer.render (dataProp) + "->" + renderer.render (literal));
}
}
}
}

O programa ao executar imprime os valores inferidos para as propriedades bornIn Year, hasAge e hasDriverAge:

propriedade de dados afirmada para Martin: bornOnDate -> 1972-10-02


propriedade de dados inferida para Martin: hasAge -> 39
propriedade de dados inferida para Martin: bornInYear -> 1972
propriedade de dados inferida para Martin: hasDriverAge -> true
propriedade de dados afirmada para Ivan: bornOnDate -> 2006-04-14
propriedade de dados inferida para Ivan: hasAge -> 5
propriedade de dados inferida para Ivan: bornInYear -> 2006

Por favor, note que as regras funcionaram em cooperação. Primeiro, a regra com o núcleo incorporado calculou o valor inteiro da propriedade
bornInYear, então a regra com o built-in personalizado calculou o valor inteiro da propriedade hasAge e, finalmente, a regra com a faixa de dados
facetada atribuída o valor booleano da propriedade hasDriverAge. Infelizmente, não sei se é possível usar o built-in interno interno do Protege 4.1.

SWRL regula com built-ins personalizados para indivíduos


A especificação SWRL permite apenas valores de dados como argumentos para built-ins. No entanto, o raciocínio Pellet é capaz de processar
regras com builtins que funcionam com indivíduos. Apenas não há documentação para isso. A única informação disponível é de um email de
Brandon Ibach e da fonte mal documentada das aulas no pacote com.clarkparsia.pellet.rules.builtins .

Eu criei uma classe CustomSWRLBuiltin.java que é semelhante à classe GeneralFunctionBuiltIn da Pellet, mas também permite indivíduos, não
apenas literais. Ele fornece uma interface CustomSWRLFunction que deve ser implementada para fornecer um built-in que pode aceitar literais e
indivíduos.

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 15/19
27/10/2017 Google Tradutor
Um exemplo de um built-in que funciona com indivíduos é um built-in que leva como entrada um indivíduo e uma seqüência separadora, obtém o IRI
do indivíduo, divide o IRI em duas partes na posição da seqüência separadora e se liga estas duas partes IRI em variáveis:

pacote cz.makub;

importar cz.makub.swrl.CustomSWRLBuiltin;
import com.clarkparsia.pellet.owlapiv3.PelletReasonerFactory;
importação com.clarkparsia.pellet.rules.builtins.BuiltInRegistry;
importação org.mindswap.pellet.ABox;
importação org.mindswap.pellet.Node;
importação org.mindswap.pellet.utils.ATermUtils;
importação org.semanticweb.owlapi.apibinding.OWLManager;
importação org.semanticweb.owlapi.io.OWLObjectRenderer;
importar org.semanticweb.owlapi.model *.;
importação org.semanticweb.owlapi.reasoner.OWLReasoner;
importação org.semanticweb.owlapi.reasoner.OWLReasonerFactory;
importação org.semanticweb.owlapi.reasoner.SimpleConfiguration;
importação org.semanticweb.owlapi.vocab.PrefixOWLOntologyFormat;
importar uk.ac.manchester.cs.owlapi.dlsyntax.DLSyntaxObjectRenderer;
importação java.util.Map;
importação java.util.Set;
importação estática org.mindswap.pellet.utils.Namespaces.XSD;
/ **
* Exemplo de um embutido Pellet SWRL que funciona com os dois indivíduos e literais de dados.
*
* Executar em Maven com <code> mvn exec: java -Dexec.mainClass = cz.makub.IndividualSWRLBuiltinTutorial </ code> *
* @author Martin Kuba makub@ics.muni.cz
* / public class IndividualSWRLBuiltinTutorial {
/ **
* a built-in implementação.
* / Classe public static IRIparts

implementa CustomSWRLBuiltin.CustomSWRLFunction {
@Override

boolean pública isApplicable ( boolean [] boundPositions) {


// aplicável apenas a 4 argumentos, dois encadernados e dois desacoplado retorno boundPositions.length == 4 && boundPositions [ 0 ] && boundPositio
}
@Override
public boolean aplicar (ABox ABOX, Nó [] args) {
// aceita IRIparts (individual, corda separador, variável independente, variável independente) se (! Args [ 0 ] .isIndividual () ||! Args [

1 ] .isLiteral () || args [ 2 ]! = nulo || args [ 3 !] = nulo ) return false ;


// obter o IRI do indivíduo no primeiro argumento iri String = args [ 0 ] .getNameStr ();
// obtém o valor da cadeia do segundo argumento separador String = ATermUtils.getLiteralValue (args [ 1 ] .getTerm ());
// dividir o IRI no separador int idx = iri.indexOf (separador);
se (idx == - 1 ) return false ;
Cadeia de prefixo = iri.substring ( 0 , idx);

ID String = iri.substring (IDX + separator.length ());


// ligar o terceiro e quarto argumentos para as peças IRI args [ 2 ] (ATermUtils.makeTypedLiteral (prefixo, XSD + = abox.addLiteral "string" ));
args [ 3 ] (ATermUtils.makeTypedLiteral (ID, XSD + = abox.addLiteral "string" ));
return true ;
}
}
// um exemplo simples ontologia private static final DOC_URL String = "http://acrab.ics.muni.cz/ontologies/swrl_tutorial_ind.owl" ;
public static void main (String [] args) lança OWLOntologyCreationException {

// registrar meu built-in implementação BuiltInRegistry.instance.registerBuiltIn ( "urn: makub: BuiltIn # IRIparts" , nova CustomSWRLBuiltin ( n
// inicializa ontologia e reasoner gerente OWLOntologyManager = OWLManager.createOWLOntologyManager ();
OWLOntology ontologia = manager.loadOntologyFromOntologyDocument (IRI.create (DOC_URL));
OWLReasonerFactory reasonerFactory = PelletReasonerFactory.getInstance ();
OWLReasoner reasoner = reasonerFactory.createReasoner (ontologia, novo SimpleConfiguration ());
Fábrica OWLDataFactory = manager.getOWLDataFactory ();

PrefixOWLOntologyFormat pm = (PrefixOWLOntologyFormat) manager.getOntologyFormat (ontologia);


// imprimir a regra SWRL listSWRLRules (ontologia, pm);
// usar a regra com o built-in para inferir valores de propriedade OWLNamedIndividual martin = factory.getOWLNamedIndividual ( ": Martin" , pm);
listAllDataPropertyValues (Martin, ontologia, Reasoner);
}
Public static void listSWRLRules (OWLOntology ontologia, PrefixOWLOntologyFormat pm) {
OWLObjectRenderer renderizador = new DLSyntaxObjectRenderer ();
para (regra SWRLRule: ontology.getAxioms (AxiomType.SWRL_RULE)) {
System.out.println (renderer.render (regra));
}
}

público static void listAllDataPropertyValues (individuais OWLNamedIndividual, OWLOntology ontologia, OWLReasoner reasoner) {
OWLObjectRenderer renderizador = new DLSyntaxObjectRenderer ();
Map <OWLDataPropertyExpression, Set <OWLLiteral >> assertedValues = individual.getDataPropertyValues (ontologia);
para (OWLDataProperty dataProp: ontology.getDataPropertiesInSignature ( verdadeiro )) {
para (OWLLiteral literais: reasoner.getDataPropertyValues (individuais, dataProp)) {
Set <OWLLiteral> literalSet = assertedValues.get (dataProp);
boolean afirmado = (literalSet =! nulos && literalSet.contains (literais));
System.out.println ((afirmado? "afirmado" : "inferir" ) + "propriedade de dados para" + renderer.render (individual) + ":" + renderer.render (
}
}
}

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 16/19
27/10/2017 Google Tradutor
}

A ontologia contém apenas um indivíduo e a seguinte regra que usa o costume embutido IRIpartsem seu corpo para dividir o IRI de cada pessoa no
ponto do caractere #. Na cabeça, a regra tem duas afirmações de propriedade de dados apenas para usar os valores de cadeia produzidos:
Pessoa, IRIparts (p?) (P, "#" ^^ xsd:??? Corda, q, r) -> hasIRIprefix (? P, q), hasIRIid (? P, r)

Quando executado, o programa deve imprimir:

hasIRIid (? p, r) ⋀ hasIRIprefix ← Pessoa ⋀ urna (p, q?) (p?): makub:?? BuiltIn # IRIparts ((p), (#), (q), (r) )
propriedade data inferida por Martin: hasIRIprefix -> http://acrab.ics.muni.cz/ontologies/swrl_tutorial_ind.owl
propriedade inferido de dados para Martin: hasIRIid -> Martin

Dicas, truques e armadilhas


Aqui eu coleciono minhas descobertas de trabalhar com coruja + SWRL ontologias.

domínios de propriedade e faixas


Uma característica surpreendente de propriedades OWL são o seu domínio e intervalos. Para aqueles que realizou algum curso em matemática, o
comportamento é contra-intuitivo. Se você definir um domínio propriedade em OWL, não é uma restrição sobre os indivíduos que podem aparecer
como a fonte da propriedade. Em vez disso, ele força qualquer indivíduo que tem essa propriedade para pertencer ao domínio.

Por exemplo, vamos definir uma propriedade olderthan com domínio Pessoa , e afirmar Martin olderthan Lenka . Então, quer por engano ou porque
é tentador reutilizar a propriedade, afirmamos Pirâmides olderthan The_Great_Wall_of_China . Em vez de uma ontologia incosistent temos um
resultado que pirâmides são uma Pessoa .

Este comportamento contra-intuitivo de properies coruja é mencionado em OWL 2 Primer, capítulo 4.8 Tipos de dados , é melhor pensar sobre os
domínios de propriedade e faixas da forma sugerida em 4,6 Domínio e restrições de intervalo , ou seja, como a adição de informações adicionais
implícita, por exemplo, que cada individual no intervalo de uma: propriedade hasWife deve ser uma mulher.

propriedades reflexivas

A relação reflexiva em matemática é uma relação binária em um conjunto para que cada elemento está relacionado a si mesmo. Seria de esperar
que a propriedade reflexiva em OWL 2 faz o mesmo em seu domínio. No entanto, não é o caso. A relação reflexiva em OWL 2 faz com que cada
indivíduo relacionado a si mesmo, seu domínio é coruja: Coisa . Se você definir um domínio para uma propriedade reflexiva, você forçar o domínio
para ser equivalente a coruja: Coisa . A razão é a definição de semântica ReflexiveObjectProperty , que diz
∀ x: x ∈ ΔI implica (x, x) ∈ (OPE) OP

onde ΔI é "domínio objeto", não o domínio da propriedade.

O que você precisa fazer é em vez de definir a reflexividade apenas no domínio. Se você procurar o objeto reflexivo Propriedadesdefinição, você
pode perceber que ele é apenas um atalho para SubClassOf( owl:Thing ObjectHasSelf( OPE ) ). Assim, podemos fazer o mesmo para
qualquer classe diferente de coruja: Coisa . Assim podemos definir, por exemplo, que apenas papéis são equalTo -se:

SubClassOf (: Papel ObjectHasSelf (: equalTo))

Negação
Embora existam construções diretos para expressar afirmações de propriedade e objeto de dados negativos, por exemplo

NegativeObjectPropertyAssertion (: hasSpouse: Martin: Peter)


NegativeDataPropertyAssertion (: hasEmail: Martin "president@whitehouse.gov")

Se você quer expressar que um indivíduo não pertence a uma classe, você tem de expressar-lo como que o indivíduo pertence ao complemento da
classe:

ClassAssertion (ObjectComplementOf (: BadGuy): Martin)

Ainda mais difícil é a de expressar um mundo "fechado", porque OWL tem o "Open World Assumption". Por exemplo, se você afirmar que "Bob tem
licença para Matlab", OWA diz que pode haver outras pessoas com a licença, apenas não sabemos quem eles são. Então, se você quer expressar
que única Bob tem uma licença para Matlab , você pode expressá-la como (em Manchester e sintaxes funcionais):

Pessoa e (não ({Bob})) EquivalentTo hasLicence max 0 ({Matlab})

EquivalentClasses (
Anotação (rdfs: comentário "Só Bob tem uma licença para Matlab")
ObjectMaxCardinality (0: hasLicence ObjectOneOf (: Matlab))
ObjectIntersectionOf (ObjectComplementOf (ObjectOneOf (Bob)): Pessoa)
)

que está dizendo " que não sejam Bob pessoas têm, no máximo, zero de licenças para Matlab ". A ObjectOneOf()expressão de classe, que define
uma classe, enumerando todos os seus membros, é a única maneira como fechar o mundo.

Se você quer ter uma regra com uma negação de uma propriedade, você também pode fazê-lo com restrição de cardinalidade (em Manchester e
sintaxes funcionais):

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 17/19
27/10/2017 Google Tradutor

Pessoa (? P), (locatedin max 0 Quarto) (p?) -> PersonNotInRoom (? P)

DLSafeRule (
Corpo(
ClassAtom (: Pessoa variável (var: p))
ClassAtom (ObjectMaxCardinality (0: locatedin: Quarto) variável (var: p))
)
Cabeça(
ClassAtom (: PersonNotInRoom variável (var: p))
)
)

ordenação parcial
Às vezes é preciso modelar uma relação que representa ordenação parcial . Não há primitivas para que em OWL 2, mas relação de ordem parcial
pode ser modelada através da criação de uma propriedade que é reflexiva, transitiva e anti-simétrica.

Um exemplo de tal propriedade é propriedade :greaterOrEqualda ontologia poset.owl que é visualizado na imagem a seguir:

O truque está em criar uma propriedade: greaterOrEqual que tem dois subpropriedades -: equalTo que é simétrica e: greaterThan que é transitivo:

Declaração (ObjectProperty (: equalTo))


Declaração (ObjectProperty (: greateOrEqual))
Declaração (ObjectProperty (: greaterThan))
SubClassOf (: Papel ObjectHasSelf (: equalTo))
TransitiveObjectProperty (: greaterThan)
SubObjectPropertyOf (: equalTo: greateOrEqual)
SubObjectPropertyOf (: greaterThan: greateOrEqual)

Limites da owl2 e SWRL


Em conhecer a tecnologia, pode ser útil para saber onde seus limites são. Em OWL 2 e SWRL, os limites são impostos principalmente pela lógica
underlaying.

Eu suponho que você já ouviu falar sobre a lógica matemática, pelo menos cerca de lógica proposicional e de primeira ordem lógica de predicados .

Para refrescar sua memória, lógica proposicional é a lógica cujas fórmulas são feitas de proposições atômicas como A, B, tendo sempre um dos
valores verdadeiros ou falsos , e conectivos lógicos como negação (¬), e (A∧B), ou (A∨B) e implicação (A → B). Lógica proposicional é som
(apenas derivando resultados corretos), completo (capaz de obter qualquer fórmula logicamente válido) e decidable (os algoritmos para decidir se
uma fórmula é final válido em tempo finito).

Lógica predicado é a lógica que adiciona predicados (como P (x, y)) que representam relações, ou seja, produzir verdadeiro ou falso para uma
combinação de valores dos termos X e Y; quantificadores : existencial ∃ ( "não existe") e ∀ universal ( "por todos"); e termosfeitas de variáveis e
funções, como f (x), g (y, z). Assim, a lógica de predicados pode formar fórmulas como ∀x∃y (P (x) → Q (f (y))).

Primeira ordem lógica de predicados é a lógica, onde os quantificadores podem variar somente sobre elementos de sets. Na lógica de ordem
superior, os quantificadores podem variar ao longo conjuntos, funções e outros objetos. Assim, por exemplo, a sentença que "cada conjunto de
números reais tem um mínimo" não pode ser expresed na lógica de primeira ordem, porque a quantificação varia ao longo sets, não definir
elementos.

Lógica de primeira ordem predicado é sólida e completa, no entanto, é não decidível . É semidecidível, fórmulas válidas pode ser provado, mas
fórmulas não-válidos podem precisar de tempo infinito para construir um contra-exemplo de tamanho infinito.

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 18/19
27/10/2017 Google Tradutor
Existem algoritmos conhecidos que podem provar teoremas válidos na lógica de primeira ordem predicado, ou seja, o algoritmo de tableaux , no
entanto, se o teorema não é válido, o algoritmo pode não terminar em tempo finito.

A linguagem OWL é baseada em lógicas de descrição (DL), o que é uma família de lógicas projetado para ser tão expressiva quanto possível,
(D) (D)
mantendo decidibilidade. O OWL versão 1 baseia-se na descrição lógica Shoin , e OWL versão 2 baseia-se no DL SROIQ .

O DL OWL 2 é um fragmento decidable da lógica de primeira ordem predicado, com algumas extensões decidíveis que vão além da lógica de
primeira ordem (ver Relacionamento com outra lógica para detalhes).

Sabe-se que OWL 1 não podem expressar o tio relação, que é uma cadeia de relações pai e irmão . OWL 2 pode expressar tio usando cadeias de
propriedade, no entanto, ainda não podem expressar relações entre os indivíduos referenciados por propriedades. Ou seja OWL 2 não podem
expressar o filho de pais casados conceito, porque ele não pode expressar a relação entre os pais do indivíduo (ver A melhor tio para OWL artigo).

Usando SWRL, podemos expressar até mesmo o filho de pais casados conceito. No entanto regras SWRL arbitrárias levaria a indecisão, portanto,
apenas o chamado DL-safe regras são implementadas em raciocinadores. Regras DL-safe são regras aplicadas apenas para indivíduos nomeados,
eles não se aplicam a pessoas que não são nomeados, mas são conhecidos de existir. Veja Quais são DL-Safe Regras SWRL? para detalhes.

Sendo um fragmento da lógica de primeira ordem predicado, o DL não podem expressar o seguinte:

expressões difusos - “É muitas vezes chove no outono.”


não-monotonicidade - “Os pássaros voam, pinguim é uma ave, mas pinguim não voa.”
atitudes proposicionais - “Eve pensa que 2 não é um número primo.” (É verdade que ela pensa isso, mas o que ela pensa não é verdade.)
lógica modal
possibilidade e necessidade - “É possível que vai chover hoje.”
modalidades epistêmicas - “Eve sabe que 2 é um número primo.”
lógica temporal - “Estou sempre com fome.”
lógica deôntica - “Você deve fazer isso.”

Vale ressaltar que há uma lógica disponíveis que podem expressar qualquer coisa pode-se dizer - a Transparente intensional Logic .Contudo, não há
raciocinadores para TIL.

https://translate.google.com.br/translate?hl=pt-BR&sl=en&u=https://dior.ics.muni.cz/~makub/owl/&prev=search 19/19