Créez des individus à l'intérieur des règles de Jena

Question

J'ai une ontologie avec beaucoup d'individus et j'utilise le raisonneur Jena pour obtenir des informations à leur sujet.Mon objectif est de créer de nouveaux individus sur la base des informations fournies dans ces règles et de leur attribuer des propriétés.Les individus n'ont pas besoin d'être nommés, mais ils ont besoin d'un type et doivent faire partie de quelques propriétés.Pour le moment, je peux créer des individus anonymes (avec l'aide d'un publication sur la liste de diffusion), mais je ne peux leur donner qu'un seul type ou une seule propriété.

Voici un petit exemple de mon problème ;ma règle ressemble à ceci (l'ontologie et le résultat déduit se trouvent en bas) :

[essai2 :(?X rdf:tapez NS:Test1) ->
[(?Y rdf:type NS:Test2) <- makeSkolem(?Y, ?X)]]

Cela signifie que lorsqu'un individu Test1 est trouvé, un nouveau nœud vide est créé, puis le type Test2 est attribué à ce nœud.Cela fonctionne bien, mais je veux donner à ces nouveaux individus une classification et un pointeur (propriété) vers ?X (les individus Test1).

Quelque chose comme ce qui suit ne fonctionne pas, puisque "les règles rétrospectives n'autorisent qu'une seule clause principale".Cependant, chaque clause fonctionne parfaitement bien.

[essai2 :(?X rdf:tapez NS:Test1) ->
[(?Y rdf:type NS:Test2), (?Y NS:hasClassification 'test'), <- makeSkolem(?Y, ?X)]]

Voici mon ontologie :

<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns="file:/Test#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" > 
  <rdf:Description rdf:about="file:/Test#hasClassification">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test#TestProp">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test#testInd">
    <rdf:type rdf:resource="file:/Test#Test1"/>
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#NamedIndividual"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test#testInd2">
    <rdf:type rdf:resource="file:/Test#Test1"/>
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#NamedIndividual"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test#Test1">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test#Test2">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Ontology"/>
  </rdf:Description>
</rdf:RDF>

C'est le résultat avec la première règle (nœuds vides avec identifiants A0 et A1 sont les nouveaux individus) :

<rdf:RDF
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns="file:/Test#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" > 
  <rdf:Description rdf:about="file:/Test#hasClassification">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#DatatypeProperty"/>
  </rdf:Description>
  <rdf:Description rdf:nodeID="A0">
    <rdf:type rdf:resource="file:/Test#Test2"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test#TestProp">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#ObjectProperty"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test#testInd">
    <rdf:type rdf:resource="file:/Test#Test1"/>
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#NamedIndividual"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test#testInd2">
    <rdf:type rdf:resource="file:/Test#Test1"/>
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#NamedIndividual"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test#Test1">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test#Test2">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Class"/>
  </rdf:Description>
  <rdf:Description rdf:nodeID="A1">
    <rdf:type rdf:resource="file:/Test#Test2"/>
  </rdf:Description>
  <rdf:Description rdf:about="file:/Test">
    <rdf:type rdf:resource="http://www.w3.org/2002/07/owl#Ontology"/>
  </rdf:Description>
</rdf:RDF>

Answer 1

Tout d’abord, notez que votre règle ne fait pas exactement ce que vous avez dit.

[essai2 :(?X rdf:type NS:Test1) →
[(?Y rdf:type NS:Test2) ← makeSkolem(?Y, ?X)]]

Cela signifie que lorsqu'un individu Test1 est trouvé, un nouveau nœud vide est créé, puis le type Test2 est attribué à ce nœud.

La règle correspond lorsqu'une instance de NS:Test1 est trouvée et ajoute une nouvelle règle de chaînage arrière qui peut être utilisée pour déterminer si quelque chose est de type NS:Test2 :si c'est le skolem de ?X, alors il a ce type.Il ne donne rien du type NS:Test2 sauf si vous le demandez.(Écrire le modèle entier, bien sûr, nécessite de tels triplets.)

Si vous trouvez ce type de comportement acceptable, vous pouvez simplement utiliser une règle de chaînage avant qui ajoute plusieurs règles de chaînage arrière, par exemple :

[essai2 :
(?X rdf:type NS:Test1) →
[(?Y rdf:type NS:Test2) ← makeSkolem(?Y, ?X)],
[(?Y NS:hasClassification 'test') ← makeSkolem(?Y, ?X)]
]

Je pense que c'est un peu plus compliqué que nécessaire.Les objets Skolem sont simplement des objets déterminés de manière unique par d'autres valeurs, vous pouvez donc utiliser makeSkolem dans les conditions préalables d'une règle ainsi qu'en tête d'une règle.Cela signifie que vous pouvez faire ceci :

[essai2 :(?X rdf:type NS:Test1), makeSkolem(?Y, ?X) →
(?Y rdf:type NS:Test2), (?Y rdf:type NS:hasClassification 'test')]

Il convient de noter que makeSkolem prend un nombre arbitraire d'arguments.Il pourrait être intéressant d'ajouter une sorte d'indicateur afin de ne pas obtenir accidentellement le même objet skolem à plusieurs endroits.Par exemple, si vous aviez quelque chose comme

[(?enfant rdf:type :Enfant), makeSkolem(?mère, ?enfant) →
(?mère rdf:type :Mère), (?enfant :hasMother ?mother)]

[(?enfant rdf:type :Enfant), makeSkolem(?père, ?enfant) →
(?père rdf:type :Père), (?enfant :hasFather ?père)]

alors tu créerais en fait juste un skolem pour chaque enfant et l'appeler la mère et le père de l'enfant, ce qui n'est probablement pas ce que vous voulez.Au lieu de cela, vous pourriez faire quelque chose comme :

[(?enfant rdf:type :Enfant), makeSkolem(?mère, ?enfant, 'mère') →
(?mère rdf:type :Mère), (?enfant :hasMother ?mother)]

[(?enfant rdf:type :Enfant), makeSkolem(?père, ?enfant, 'père') →
(?père rdf:type :Père), (?enfant :hasFather ?père)]

depuis (?child, 'mother') et (?child, 'father') sont toujours différents, vous obtenez deux objets skolem au lieu d'un seul.Vous pouvez utiliser quelque chose comme ceci dans votre règle pour obtenir, par exemple :

[essai2 :(?X rdf:type NS:Test1), makeSkolem(?Y, ?X, 'test2') →
(?Y rdf:type NS:Test2), (?Y NS:hasClassification 'test')]