Because an OWL reasoner will only return named (non-anonymous) superclasses, we add a
* pre-processing step, where for each class C appearing in either LHS or RHS of a SubClassOf
* expression, if C is anonymous, we create a named class C' and add a temporary axioms
* EquivalentClasses(C' C), which is later removed as a post-processing step. When performing
@@ -46,7 +32,7 @@
*
*
+ * We make a special additional case of redunancy, as in the following example:
* 1. (hand and part-of some human) SubClassOf part-of some forelimb
* 2. hand SubClassOf part-of some forelimb
* Here we treat axiom 1 as redundant, but this is not detected by the algorithm above,
@@ -68,6 +54,7 @@ public class ReduceOperation {
public static Map getDefaultOptions() {
Map options = new HashMap<>();
options.put("preserve-annotated-axioms", "false");
+ options.put("named-classes-only", "false");
return options;
}
@@ -94,6 +81,27 @@ public static void reduce(OWLOntology ontology, OWLReasonerFactory reasonerFacto
public static void reduce(
OWLOntology ontology, OWLReasonerFactory reasonerFactory, Map options)
throws OWLOntologyCreationException {
+ boolean preserveAnnotatedAxioms =
+ OptionsHelper.optionIsTrue(options, "preserve-annotated-axioms");
+ boolean namedClassesOnly = OptionsHelper.optionIsTrue(options, "named-classes-only");
+ if (namedClassesOnly) {
+ reduceNamedOnly(ontology, reasonerFactory, preserveAnnotatedAxioms);
+ } else {
+ reduceAllClassExpressions(ontology, reasonerFactory, preserveAnnotatedAxioms);
+ }
+ }
+
+ /**
+ * Remove redundant SubClassOf axioms.
+ *
+ * @param ontology The ontology to reduce.
+ * @param reasonerFactory The reasoner factory to use.
+ * @param preserveAnnotatedAxioms Whether to not remove redundant, but annotated, axioms.
+ * @throws OWLOntologyCreationException on ontology problem
+ */
+ private static void reduceAllClassExpressions(
+ OWLOntology ontology, OWLReasonerFactory reasonerFactory, boolean preserveAnnotatedAxioms)
+ throws OWLOntologyCreationException {
OWLOntologyManager manager = OWLManager.createOWLOntologyManager();
OWLDataFactory dataFactory = manager.getOWLDataFactory();
@@ -166,7 +174,7 @@ public static void reduce(
Set rmAxioms = new HashSet<>();
for (OWLSubClassOfAxiom ax : assertedSubClassAxioms) {
- if (OptionsHelper.optionIsTrue(options, "preserve-annotated-axioms")) {
+ if (preserveAnnotatedAxioms) {
if (ax.getAnnotations().size() > 0) {
logger.debug("Protecting axiom with annotations: " + ax);
continue;
@@ -254,6 +262,7 @@ public static void reduce(
for (OWLAxiom ax : rmAxioms) {
manager.removeAxiom(ontology, ax);
}
+ reasoner.dispose();
}
/**
@@ -279,4 +288,93 @@ private static OWLClass mapClass(
}
return rxmap.get(x);
}
+
+ /**
+ * Remove redundant SubClassOf axioms, only considering named classes. When only considering named
+ * classes, a somewhat more efficient algorithm can be used.
+ *
+ * @param ontology The ontology to reduce.
+ * @param reasonerFactory The reasoner factory to use.
+ * @param preserveAnnotatedAxioms Whether to not remove redundant, but annotated, axioms.
+ */
+ private static void reduceNamedOnly(
+ OWLOntology ontology, OWLReasonerFactory reasonerFactory, boolean preserveAnnotatedAxioms) {
+ // Map>
+ Map>> assertions = new HashMap<>();
+ Set assertedSubClassAxioms = ontology.getAxioms(AxiomType.SUBCLASS_OF);
+ for (OWLSubClassOfAxiom ax : assertedSubClassAxioms) {
+ if (!ax.getSubClass().isAnonymous() && !ax.getSuperClass().isAnonymous()) {
+ OWLClass subclass = ax.getSubClass().asOWLClass();
+ OWLClass superclass = ax.getSuperClass().asOWLClass();
+ if (!assertions.containsKey(superclass)) {
+ assertions.put(superclass, new HashMap<>());
+ }
+ Map> subMap = assertions.get(superclass);
+ if (!subMap.containsKey(subclass)) {
+ subMap.put(subclass, new HashSet<>());
+ }
+ Set axioms = subMap.get(subclass);
+ axioms.add(ax);
+ }
+ }
+ OWLReasoner reasoner = reasonerFactory.createReasoner(ontology);
+ if (!reasoner.isConsistent()) {
+ logger.info("Ontology is not consistent!");
+ return;
+ }
+ Node unsatisfiableClasses = reasoner.getUnsatisfiableClasses();
+ if (unsatisfiableClasses.getSize() > 1) {
+ logger.info(
+ "There are {} unsatisfiable classes in the ontology.", unsatisfiableClasses.getSize());
+ for (OWLClass cls : unsatisfiableClasses) {
+ if (!cls.isOWLNothing()) {
+ logger.info(" unsatisfiable: " + cls.getIRI());
+ }
+ }
+ }
+ Set nonredundant = new HashSet<>();
+ Set> alreadySeen = new HashSet<>();
+ findNonRedundant(reasoner.getTopClassNode(), reasoner, assertions, nonredundant, alreadySeen);
+ OWLOntologyManager manager = ontology.getOWLOntologyManager();
+ for (OWLSubClassOfAxiom ax : assertedSubClassAxioms) {
+ if (!ax.getSubClass().isAnonymous() && !ax.getSuperClass().isAnonymous()) {
+ if (preserveAnnotatedAxioms) {
+ if (ax.getAnnotations().size() > 0) {
+ logger.debug("Protecting axiom with annotations: " + ax);
+ continue;
+ }
+ }
+ if (!nonredundant.contains(ax)) {
+ manager.removeAxiom(ontology, ax);
+ }
+ }
+ }
+ reasoner.dispose();
+ }
+
+ private static void findNonRedundant(
+ Node node,
+ OWLReasoner reasoner,
+ Map>> assertions,
+ Set nonredundant,
+ Set> alreadySeen) {
+ if (!alreadySeen.contains(node)) {
+ NodeSet subclasses = reasoner.getSubClasses(node.getRepresentativeElement(), true);
+ for (OWLClass superclass : node.getEntities()) {
+ for (OWLClass subclass : subclasses.getFlattened()) {
+ if (assertions.containsKey(superclass)) {
+ Map> subclassAxiomsBySubclass =
+ assertions.get(superclass);
+ if (subclassAxiomsBySubclass.containsKey(subclass)) {
+ nonredundant.addAll(subclassAxiomsBySubclass.get(subclass));
+ }
+ }
+ }
+ }
+ alreadySeen.add(node);
+ for (Node subclassNode : subclasses.getNodes()) {
+ findNonRedundant(subclassNode, reasoner, assertions, nonredundant, alreadySeen);
+ }
+ }
+ }
}
diff --git a/robot-core/src/test/java/org/obolibrary/robot/ReduceOperationTest.java b/robot-core/src/test/java/org/obolibrary/robot/ReduceOperationTest.java
index 001ac700c..022b1be15 100644
--- a/robot-core/src/test/java/org/obolibrary/robot/ReduceOperationTest.java
+++ b/robot-core/src/test/java/org/obolibrary/robot/ReduceOperationTest.java
@@ -29,6 +29,16 @@ public void testRemoveRedundantSubClassAxiomsPreserveAnnotated()
ReduceOperation.reduce(reasoned, reasonerFactory, options);
assertIdentical("/without_redundant_subclasses.owl", reasoned);
+
+ OWLOntology reasoned2 = loadOntology("/redundant_subclasses.owl");
+
+ Map options2 = new HashMap();
+ options2.put("remove-redundant-subclass-axioms", "true");
+ options2.put("preserve-annotated-axioms", "true");
+ options2.put("named-classes-only", "true");
+
+ ReduceOperation.reduce(reasoned2, reasonerFactory, options2);
+ assertIdentical("/without_redundant_subclasses.owl", reasoned2);
}
@Test
@@ -156,4 +166,22 @@ public void testReduceDomainCase() throws IOException, OWLOntologyCreationExcept
ReduceOperation.reduce(reasoned, reasonerFactory, options);
assertIdentical("/reduce-domain-test.owl", reasoned);
}
+
+ /** Test reduce only named classes vs. including expressions */
+ @Test
+ public void testReducedNamedOnly() throws OWLOntologyCreationException, IOException {
+ OWLReasonerFactory reasonerFactory = new org.semanticweb.elk.owlapi.ElkReasonerFactory();
+
+ OWLOntology ontologyA = loadOntology("/reduce-named-only-test.ofn");
+ Map optionsA = new HashMap();
+ optionsA.put("named-classes-only", "true");
+ ReduceOperation.reduce(ontologyA, reasonerFactory, optionsA);
+ assertIdentical("/reduce-named-only-test-named-only-true-reduced.ofn", ontologyA);
+
+ OWLOntology ontologyB = loadOntology("/reduce-named-only-test.ofn");
+ Map optionsB = new HashMap();
+ optionsB.put("named-classes-only", "false");
+ ReduceOperation.reduce(ontologyB, reasonerFactory, optionsB);
+ assertIdentical("/reduce-named-only-test-named-only-false-reduced.ofn", ontologyB);
+ }
}
diff --git a/robot-core/src/test/resources/reduce-named-only-test-named-only-false-reduced.ofn b/robot-core/src/test/resources/reduce-named-only-test-named-only-false-reduced.ofn
new file mode 100644
index 000000000..ae01b02f7
--- /dev/null
+++ b/robot-core/src/test/resources/reduce-named-only-test-named-only-false-reduced.ofn
@@ -0,0 +1,38 @@
+Prefix(:=)
+Prefix(owl:=)
+Prefix(rdf:=)
+Prefix(xml:=)
+Prefix(xsd:=)
+Prefix(rdfs:=)
+
+
+Ontology(
+
+Declaration(Class())
+Declaration(Class())
+Declaration(Class())
+Declaration(Class())
+Declaration(ObjectProperty())
+
+############################
+# Classes
+############################
+
+# Class: ()
+
+SubClassOf( ObjectSomeValuesFrom( ))
+
+# Class: ()
+
+SubClassOf( )
+
+# Class: ()
+
+SubClassOf( )
+
+# Class: ()
+
+SubClassOf( )
+
+
+)
\ No newline at end of file
diff --git a/robot-core/src/test/resources/reduce-named-only-test-named-only-true-reduced.ofn b/robot-core/src/test/resources/reduce-named-only-test-named-only-true-reduced.ofn
new file mode 100644
index 000000000..51735e61d
--- /dev/null
+++ b/robot-core/src/test/resources/reduce-named-only-test-named-only-true-reduced.ofn
@@ -0,0 +1,40 @@
+Prefix(:=)
+Prefix(owl:=)
+Prefix(rdf:=)
+Prefix(xml:=)
+Prefix(xsd:=)
+Prefix(rdfs:=)
+
+
+Ontology(
+
+Declaration(Class())
+Declaration(Class())
+Declaration(Class())
+Declaration(Class())
+Declaration(ObjectProperty())
+
+############################
+# Classes
+############################
+
+# Class: ()
+
+SubClassOf( ObjectSomeValuesFrom( ))
+
+# Class: ()
+
+SubClassOf( )
+SubClassOf( ObjectSomeValuesFrom( ))
+
+# Class: ()
+
+SubClassOf( )
+
+# Class: ()
+
+SubClassOf( )
+SubClassOf( ObjectSomeValuesFrom( ))
+
+
+)
\ No newline at end of file
diff --git a/robot-core/src/test/resources/reduce-named-only-test.ofn b/robot-core/src/test/resources/reduce-named-only-test.ofn
new file mode 100644
index 000000000..1f29cc8a3
--- /dev/null
+++ b/robot-core/src/test/resources/reduce-named-only-test.ofn
@@ -0,0 +1,41 @@
+Prefix(:=)
+Prefix(owl:=)
+Prefix(rdf:=)
+Prefix(xml:=)
+Prefix(xsd:=)
+Prefix(rdfs:=)
+
+
+Ontology(
+
+Declaration(Class())
+Declaration(Class())
+Declaration(Class())
+Declaration(Class())
+Declaration(ObjectProperty())
+
+############################
+# Classes
+############################
+
+# Class: ()
+
+SubClassOf( ObjectSomeValuesFrom( ))
+
+# Class: ()
+
+SubClassOf( )
+SubClassOf( ObjectSomeValuesFrom( ))
+
+# Class: ()
+
+SubClassOf( )
+
+# Class: ()
+
+SubClassOf( )
+SubClassOf( )
+SubClassOf( ObjectSomeValuesFrom( ))
+
+
+)
\ No newline at end of file