Creare individui all'interno delle regole Jena

Question

Ho un'ontologia con un sacco di individui e usa il ragionamento Jena per ottenere informazioni su di loro. Il mio obiettivo è creare nuovi individui in base alle informazioni fornite all'interno di quelle regole e assegna loro proprietà. Gli individui non devono essere nominati, ma hanno bisogno di un tipo e devono essere parte di alcune proprietà. Al momento posso creare individui anonimi (con l'aiuto di un mailing list post ), ma posso solo dare loro un tipo o una proprietà.

Ecco un piccolo esempio del mio problema; La mia regola è simile a questa (l'ontologia e il risultato dedotto può essere trovato in fondo):

.

[TEST2: (? X RDF: Digitare NS: Test1) ->
[(? Y RDF: Type NS: Test2) <- Makekolem (? Y ,? x)]]

Significa che quando viene trovato un individuo Test1, viene creato un nuovo nodo vuoto e quindi il test Test2 viene dato a quel nodo. Funziona bene, ma voglio dare a questo nuovo individuo una classificazione e un puntatore (proprietà) a? X (il test1 individui).

Qualcosa come il seguente non funziona, poiché "Regole all'indietro permettere solo una clausola della testa". Ogni clausola per il suo funziona perfettamente bene però.

.

[TEST2: (? X RDF: Digitare NS: Test1) ->
[(? Y RDF: Type NS: Test2), (? Y NS: HasClassification 'Test'), <- Makekolem (? Y,? X)]]

Questa è la mia ontologia:

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

.

Questo è il risultato con la prima regola (nodi vuoti con ID A0 e A1 sono i nuovi individui):

<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

In primo luogo, nota che la tua regola non fa esattamente quello che hai detto lo fa.

.

[TEST2: (? X RDF: Tipo NS: Test1) →
[(? Y RDF: Type NS: Test2) ← Makekolem (? Y,? X)]]

Significa che quando viene trovato un individuo Test1, quindi viene creato un nuovo nodo vuoto e quindi il test Test2 è dato a quel nodo.

La regola corrisponde quando viene trovata un'istanza di NS: Test1 e aggiunge una nuova regola di concatenamento all'indietro che può essere utilizzata quando si determina se qualcosa ha il tipo NS: TEST2: se è lo skolem di? X, allora ha quel tipo. Non dà nulla il tipo ns: test2 a meno che tu non lo chieda. (Scrivere l'intero modello, ovviamente, chiede tali triple.)

Se trovi che il tipo di comportamento accettabile, è possibile utilizzare semplicemente una regola a catena in avanti che aggiunge più regole di concatenamento all'indietro, ad esempio.:

.

[TEST2:
(? X RDF: Type NS: Test1) →
[(? Y RDF: Type NS: Test2) ← Makekolem (? Y,? X)],
[(? Y NS: HasClassification 'Test') ← Makekolem (? Y,? X)]
]

Penso che sia un po 'più complicato di quanto debba essere. Gli oggetti Skolem sono semplicemente oggetti determinati in modo univoco da alcuni altri valori, in modo da poter utilizzare Makekolem nelle precondizioni di una regola e il capo di una regola. Ciò significa che puoi farlo:

.

[TEST2: (? X RDF: Type NS: Test1), MakeLem (? Y ,? X) →
(? Y RDF: Type NS: Test2), (? Y RDF: Type NS: HasClassification 'Test')]

Vale la pena notare che Makekolem prende un numero arbitrario di argomenti. Potrebbe valere la pena aggiungere una sorta di indicatore in modo da non ottenere accidentalmente lo stesso oggetto Skolem in più luoghi. E.g., se avessi qualcosa come

.

[(? Bambino RDF: Tipo: Bambino), MakeLem (? Madre ,? Bambino) →
(? Madre RDF: Tipo: Madre), (? Bambino: Hasmother? Madre)]

[(? Bambino RDF: Tipo: Bambino), MakeLem (? Padre, Bambino) →
(? Padre RDF: Tipo: Padre), (? Bambino: Hasfather? Padre)]

Allora creeresti in realtà solo uno oggetto skolem per ogni bambino e chiamandolo la madre e il padre del bambino, che probabilmente non è quello che vuoi. Invece, potresti fare qualcosa come:

.

[(? Bambino RDF: Tipo: Bambino), MakeLem (? Madre ,? Bambino, "Madre") →
(? Madre RDF: Tipo: Madre), (? Bambino: Hasmother? Madre)]

[(? Bambino RDF: Tipo: Bambino), MakeLem (? Padre, "Bambino," Padre ") →
(? Padre RDF: Tipo: Padre), (? Bambino: Hasfather? Padre)]

Dal momento che (?child, 'mother') e (?child, 'father') sono sempre diversi, ottieni due oggetti Skolem invece di uno solo. Potresti usare qualcosa del genere nella tua regola per ottenere, ad esempio, E.G.,

.

[TEST2: (? X RDF: Digitare NS: Test1), MakeLem (? Y ,? X, 'Test2') →
(? Y RDF: Type NS: TEST2), (? Y NS: HASCLASSIFICHE 'TEST')]