Академический Документы
Профессиональный Документы
Культура Документы
© 2012
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.
A afirmação da subclasse declara que todos os indivíduos que pertencem a uma classe pertencem também a outra classe.
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:
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.
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.
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 .
ObjectPropertyAssertion (: isPartOf: SC
ObjectPropertyAssertion (: isPartOf: IC
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.
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
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.
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:
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:
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:
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:
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.
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:
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
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:
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.
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:
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.
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)
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:
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.
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
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 {
// 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));
}
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);
/ **
* 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 ());
}
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
Predicados SWRL
As regras SWRL podem usar outros predicados do que apenas nomes de classe ou propriedade. Os predicados podem ser
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:
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)
(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.
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
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.
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:
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)
)
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.
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.
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;
/ **
* 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 {
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:
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.
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
// 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 ();
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)
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
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
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:
Negação
Embora existam construções diretos para expressar afirmações de propriedade e objeto de dados negativos, por exemplo
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:
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):
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
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:
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:
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