How to use

isSatisfiable

method

in

org.semanticweb.owlapi.reasoner.OWLReasoner

/**
 * Range(R) = C is tautology iff ER.~C is unsatisfiable
 */
@Override
public void visit(OWLObjectPropertyRangeAxiom axiom) {
  isLocal = true;
  for (OWLClassExpression e : exprMap.get(axiom)) {
    isLocal &= !kernel.isSatisfiable(e);
  }
}

@Override
public void visit(OWLDataPropertyRangeAxiom axiom) {
  isLocal = true;
  for (OWLClassExpression e : exprMap.get(axiom)) {
    isLocal &= !kernel.isSatisfiable(e);
  }
}

@Override
public void visit(OWLDataPropertyRangeAxiom axiom) {
  isLocal = true;
  for (OWLClassExpression e : exprMap.get(axiom)) {
    isLocal &= !kernel.isSatisfiable(e);
  }
}

/**
 * Range(R) = C is tautology iff ER.~C is unsatisfiable
 */
@Override
public void visit(OWLObjectPropertyRangeAxiom axiom) {
  isLocal = true;
  for (OWLClassExpression e : exprMap.get(axiom)) {
    isLocal &= !kernel.isSatisfiable(e);
  }
}

@Override
public void visit(OWLDataPropertyRangeAxiom axiom) {
  isLocal = true;
  for (OWLClassExpression e : exprMap.get(axiom)) {
    isLocal &= !kernel.isSatisfiable(e);
  }
}

@Override
public void visit(OWLDataPropertyRangeAxiom axiom) {
  isLocal = true;
  for (OWLClassExpression e : exprMap.get(axiom)) {
    isLocal &= !kernel.isSatisfiable(e);
  }
}

/**
 * Range(R) = C is tautology iff ER.~C is unsatisfiable
 */
@Override
public void visit(OWLObjectPropertyRangeAxiom axiom) {
  isLocal = true;
  for (OWLClassExpression e : exprMap.get(axiom)) {
    isLocal &= !kernel.isSatisfiable(e);
  }
}

/**
 * Range(R) = C is tautology iff ER.~C is unsatisfiable
 */
@Override
public void visit(OWLObjectPropertyRangeAxiom axiom) {
  isLocal = true;
  for (OWLClassExpression e : exprMap.get(axiom)) {
    isLocal &= !kernel.isSatisfiable(e);
  }
}

/**
 * Range(R) = C is tautology iff ER.~C is unsatisfiable
 */
@Override
public void visit(OWLObjectPropertyRangeAxiom axiom) {
  isLocal = true;
  for (OWLClassExpression e : exprMap.get(axiom)) {
    isLocal &= !kernel.isSatisfiable(e);
  }
}

/**
 * Range(R) = C is tautology iff ER.~C is unsatisfiable
 */
@Override
public void visit(OWLObjectPropertyRangeAxiom axiom) {
  isLocal = true;
  for (OWLClassExpression e : exprMap.get(axiom)) {
    isLocal &= !kernel.isSatisfiable(e);
  }
}

protected Set<? extends OWLClassExpression> getEquivalentClasses(OWLClass cls) {
  OWLReasoner myReasoner = reasoner;
  // Get the equivalent classes from the reasoner
  if (myReasoner == null) {
    return Collections.emptySet();
  }
  if (!myReasoner.isSatisfiable(cls)) {
    // We don't want every class in the ontology
    return Collections.emptySet();
  }
  return myReasoner.getEquivalentClasses(cls).getEntities();
}

protected Set<? extends OWLClassExpression> getEquivalentClasses(OWLClass cls) {
  // Get the equivalent classes from the reasoner
  if (reasoner == null) {
    return Collections.emptySet();
  }
  if (!reasoner.isSatisfiable(cls)) {
    // We don't want every class in the ontology
    return Collections.emptySet();
  }
  return reasoner.getEquivalentClasses(cls).getEntities();
}

public Set<OWLClass> getChildren(OWLClass object) {
  // Simply get the superclasses from the reasoner
  if (reasoner == null) {
    return Collections.emptySet();
  }
  if (!reasoner.isSatisfiable(object)) {
    // We don't want every class in the ontology!!
    return Collections.emptySet();
  }
  return reasoner.getSuperClasses(object, true).getFlattened();
}

public void visit(OWLDisjointClassesAxiom axiom) {
  Set<OWLClassExpression> disjClasses = axiom.getClassExpressions();
  OWLClassExpression conjunction = df.getOWLObjectIntersectionOf(disjClasses);
  if (log.isLoggable(Level.FINE))
    log.fine("Calling the Reasoner");
  isLocal = !reasoner.isSatisfiable(df.getOWLNothing());
  if (log.isLoggable(Level.FINE))
    log.fine("DONE Calling the Reasoner. isLocal = " + isLocal);
}

protected void updateUnsatisfiableDependents(OWLClassExpression op) {
  if (op.isAnonymous()) {
    op.accept(this);
  }
  else {
    if (!reasoner.isSatisfiable(op)) {
      dependsOn.add(op.asOWLClass());
    }
  }
}

private boolean isSatisfiable(@Nonnull OWLObject owlObject) {
  return !(owlObject instanceof OWLClass) || editorKit.getOWLModelManager()
                            .getOWLReasonerManager()
                            .getCurrentReasoner()
                            .isSatisfiable((OWLClass) owlObject);
}

public Set<OWLClass> getEquivalents(OWLClass object) {
  if (!getReasoner().isSatisfiable(object)) {
    return Collections.emptySet();
  }
  Set<OWLClass> equivalents = getReasoner().getEquivalentClasses(object).getEntities();
  equivalents.remove(object);
  return equivalents;
}

protected void addAxioms(OWLClass entity, OWLReasoner reasoner, OWLDataFactory dataFactory, Set<OWLSubClassOfAxiom> result) {
  if (reasoner.isSatisfiable(entity)) {
    for (OWLClass sup : reasoner.getSuperClasses(entity, true).getFlattened()) {
      result.add(dataFactory.getOWLSubClassOfAxiom(entity, sup));
    }
  }
  else {
    result.add(dataFactory.getOWLSubClassOfAxiom(entity, dataFactory.getOWLNothing()));
  }
}

@Override
public boolean canAs(OWLNamedIndividual i, OWLClass c) {
  OWLDataFactory factory = ontology.getOWLOntologyManager().getOWLDataFactory();
  return reasoner.isSatisfiable(factory.getOWLObjectIntersectionOf(c, factory.getOWLObjectOneOf(i)));
}

  public void run() {
    OWLReasoner reasoner = getOWLModelManager().getReasoner();
    boolean consistent = reasoner.isConsistent();
    if (!consistent || !getOWLModelManager().getReasoner().isSatisfiable((OWLClass) curEntity)) {
      // Paint red because of inconsistency
      doc.setCharacterAttributes(tokenStartIndex, tokenLength, inconsistentClassStyle, true);
    }
  }
});