your mistake is here:
Triple sameAsTriple =new Triple(
ontModel.getResource("http://test/kbA#memberA";).asNode(),
ontModel.getResource("owl:sameAs").asNode(),
ontModel.getResource("http://test/kbB#memberB";).asNode());
the methods expects a proper URI, not a prefixed one - the reason for
this is that there is nothing that would prevent users from using the
the prefix owl: for some other namespace, so Jena can't guess here
You could indeed also make use of Jena built-in vocab methods:
Triple sameAsTriple =new Triple(
ontModel.getResource("http://test/kbA#memberA";).asNode(), OWL.sameAs.asNode(),
ontModel.getResource("http://test/kbB#memberB";).asNode());
or indeed just use the full URI of owl:sameAs
Cheers,
Lorenz
On 28.10.22 14:26, Steve Vestal wrote:
I make a call model.remove(statement) for a statement that is listed
in that model, but that statement stays listed.
The following example code is a bit lengthy due to setup and
alternatives tried, but it is executable (with Jena imports added). I
think this is a simple misunderstanding of models, statements, and
triples. Look for the "Why doesn't this work?" comment and the print
of "base contents after remove". How should this be done? I am
using Jena 4.5.0.
public class BaseModelEdits {
public static void main(String args[]) {
// Jena documentation says,
// "And when we update the model, only the base model
changes."
// Create two knowledge bases that will not change during
use.
OntModel kbA =
ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
OntClass classA = kbA.createClass("http://test/kbA#classA";);
kbA.createIndividual("http://test/kbA#memberA";, classA);
kbA.createIndividual("http://test/kbA#memberC";, classA);
OntModel kbB =
ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
OntClass classB = kbB.createClass("http://test/kbB#classB";);
kbB.createIndividual("http://test/kbB#memberB";, classB);
kbB.createIndividual("http://test/kbB#memberD";, classB);
// Create initial content for an editable base model
OntModel initialBase =
ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
OntResource memA =
initialBase.createOntResource("http://test/kbA#memberA";);
OntResource memB =
initialBase.createOntResource("http://test/kbB#memberB";);
memA.addSameAs(memB);
// Create an OntModel with the initial base plain Model
content.
OntModel ontModel =
ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_MICRO_RULE_INF,
initialBase.getBaseModel());
// None of the above have import statements (for reasons I
won't go into).
// Add the knowledge bases as plan Model subModels.
ontModel.addSubModel(kbA.getBaseModel());
ontModel.addSubModel(kbB.getBaseModel());
Individual memberA =
ontModel.getIndividual("http://test/kbA#memberA";);
Individual memberB =
ontModel.getIndividual("http://test/kbB#memberB";);
Individual memberC =
ontModel.getIndividual("http://test/kbA#memberC";);
Individual memberD =
ontModel.getIndividual("http://test/kbB#memberD";);
System.out.println("memberA sameAs memberB true = " +
memberA.isSameAs(memberB));
System.out.println("memberA sameAs memberC false = " +
memberA.isSameAs(memberC));
System.out.println("memberA sameAs memberD false = " +
memberA.isSameAs(memberD));
System.out.println("memberB sameAs memberC false = " +
memberB.isSameAs(memberC));
System.out.println("memberB sameAs memberD false = " +
memberB.isSameAs(memberD));
System.out.println();
// Approach 1: Selectively remove the sameAs assertion
// Why doesn't this work?
System.out.println("initial base contents");
StmtIterator baseStmts =
ontModel.getBaseModel().listStatements();
while (baseStmts.hasNext()) {
System.out.println(" " +
baseStmts.next().asTriple().toString());
}
// Removing the sameAs assertion will require knowing how
it is encoded.
// None of the following three Triple formulations work.
// Triple sameAsTriple = new
Triple(NodeFactory.createURI("http://test/kbA#memberA";),
// NodeFactory.createURI("owl:sameAs"),
NodeFactory.createURI("http://test/kbB#memberB";));
Triple sameAsTriple = new Triple(
ontModel.getResource("http://test/kbA#memberA";).asNode(),
ontModel.getResource("owl:sameAs").asNode(),
ontModel.getResource("http://test/kbB#memberB";).asNode());
// Triple sameAsTriple = new Triple(
//
ontModel.getBaseModel().getResource("http://test/kbA#memberA";).asNode(),
// ontModel.getBaseModel().getResource("owl:sameAs").asNode(),
//
ontModel.getBaseModel().getResource("http://test/kbB#memberB";).asNode());
// The following three statements do not work.
Statement assertSameAs = ontModel.asStatement(sameAsTriple);
ontModel.add(assertSameAs); // Makes no difference
ontModel.remove(assertSameAs);
// These three do not not work either.
// Making changes via the OntModel is needed anyway (for
reasons I won't go into).
// Statement assertSameAs =
ontModel.getBaseModel().asStatement(sameAsTriple);
// ontModel.getBaseModel().add(assertSameAs); // Makes
no difference
// ontModel.getBaseModel().remove(assertSameAs);
ontModel.rebind();
System.out.println("base contents after remove " +
assertSameAs.asTriple().toString());
baseStmts = ontModel.getBaseModel().listStatements();
while (baseStmts.hasNext()) {
System.out.println(" " +
baseStmts.next().asTriple().toString());
}
System.out.println("memberA sameAs memberB false = " +
memberA.isSameAs(memberB));
System.out.println("memberA sameAs memberC false = " +
memberA.isSameAs(memberC));
System.out.println("memberA sameAs memberD false = " +
memberA.isSameAs(memberD));
System.out.println("memberB sameAs memberC false = " +
memberB.isSameAs(memberC));
System.out.println("memberB sameAs memberD false = " +
memberB.isSameAs(memberD));
System.out.println();
// Approach 2: Remove everything in the base model.
// This works.
ontModel.getBaseModel().removeAll();
// A rebind is necessary here.
// Would any of the reasoners do incremental rebinding
// if they knew only certain assertions changed?
ontModel.rebind();
System.out.println("base contents after removeAll ");
baseStmts = ontModel.getBaseModel().listStatements();
while (baseStmts.hasNext()) {
System.out.println(" " +
baseStmts.next().asTriple().toString());
}
System.out.println("memberA sameAs memberB false = " +
memberA.isSameAs(memberB));
System.out.println("memberA sameAs memberC false = " +
memberA.isSameAs(memberC));
System.out.println("memberA sameAs memberD false = " +
memberA.isSameAs(memberD));
System.out.println("memberB sameAs memberC false = " +
memberB.isSameAs(memberC));
System.out.println("memberB sameAs memberD false = " +
memberB.isSameAs(memberD));
}
}
