java.lang.Object

it.poliba.sisinflab.tinyme.Reasoner

All Implemented Interfaces:: OWLReasoner

public final class Reasoner
extends Object
implements OWLReasoner

The main reasoner class, exposing standard and non-standard inference tasks.

Non-standard matchmaking services are detailed in Ruta et al., WIAS 2011. For more information about the project, visit Tiny-ME's website.

Reasoner objects can be instantiated via the ReasonerFactory class.

See Also:: The OWL API.

Method Summary

Modifier and Type	Method	Description
`Abduction`	`abduction(SemanticDescription resource, SemanticDescription request)`	This method is the same as `abduction(OWLNamedIndividual, OWLNamedIndividual)`, with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
`Abduction`	`abduction(IRI resourceIri, IRI requestIri)`	Refer to `abduction(OWLNamedIndividual, OWLNamedIndividual)`.
`Abduction`	`abduction(OWLNamedIndividual resource, OWLNamedIndividual request)`	Performs the Concept Abduction non-standard matchmaking task, comparing a requested semantic profile with a supplied resource.
`Bonus`	`bonus(SemanticDescription resource, SemanticDescription request)`	This method is the same as `bonus(OWLNamedIndividual, OWLNamedIndividual)`, with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
`Bonus`	`bonus(IRI resourceIri, IRI requestIri)`	Refer to `bonus(OWLNamedIndividual, OWLNamedIndividual)`.
`Bonus`	`bonus(OWLNamedIndividual resource, OWLNamedIndividual request)`	Performs the Concept Bonus non-standard matchmaking task, comparing a requested semantic profile with a supplied resource.
`Reasoner`	`classify()`	Computes the taxonomy of classes present in the root ontology.
`Contraction`	`contraction(SemanticDescription resource, SemanticDescription request)`	This method is the same as `contraction(OWLNamedIndividual, OWLNamedIndividual)`, with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
`Contraction`	`contraction(IRI resourceIri, IRI requestIri)`	Refer to `contraction(OWLNamedIndividual, OWLNamedIndividual)`.
`Contraction`	`contraction(OWLNamedIndividual resource, OWLNamedIndividual request)`	Performs the Concept Contraction non-standard matchmaking task, comparing a requested semantic profile with a supplied resource.
`Composition`	`covering(SemanticDescription request)`	This method is the same as `covering(OWLNamedIndividual)`, with the difference that the provided description doesn't need to belong to an individual loaded into the reasoner.
`Composition`	`covering(IRI iri)`	Refer to `covering(OWLNamedIndividual)`.
`Composition`	`covering(OWLNamedIndividual request)`	Performs the Concept Covering non-standard matchmaking task, comparing a requested semantic profile with available resources.
`SemanticDescription`	`difference(SemanticDescription lhs, SemanticDescription rhs)`	This method is the same as `difference(OWLNamedIndividual, OWLNamedIndividual)`, with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
`SemanticDescription`	`difference(IRI lhs, IRI rhs)`	Refer to `difference(OWLNamedIndividual, OWLNamedIndividual)`.
`SemanticDescription`	`difference(OWLNamedIndividual lhs, OWLNamedIndividual rhs)`	Computes the Concept Difference between two individuals.
`void`	`dispose()`	Disposes of this reasoner.
`void`	`flush()`	Flushes any changes stored in the buffer, which causes the reasoner to take into consideration the changes the current root ontology specified by the changes.
`SemanticDescription`	`fold(SemanticDescription description)`	Folds the specified semantic description.
`Stream<EntityDescription<OWLNamedIndividual>>`	`getABox()`	Returns the ABox loaded into this reasoner.
`Node<OWLClass>`	`getBottomClassNode()`	Gets the `Node` corresponding to the bottom node (containing `owl:Nothing`) in the class hierarchy.
`Node<OWLDataProperty>`	`getBottomDataPropertyNode()`	Gets the `Node` corresponding to the bottom node (containing `owl:bottomDataProperty`) in the data property hierarchy.
`Node<OWLObjectPropertyExpression>`	`getBottomObjectPropertyNode()`	Gets the `Node` corresponding to the bottom node (containing `owl:bottomObjectProperty`) in the object property hierarchy.
`BufferingMode`	`getBufferingMode()`	Gets the buffering mode of this reasoner.
`EntityDescription<OWLClass>`	`getClassDescription(IRI iri)`	Refer to `getDescription(OWLClass)`.
`DataFactory`	`getDataFactory()`	Returns the data factory of this reasoner.
`NodeSet<OWLClass>`	`getDataPropertyDomains(OWLDataProperty pe, boolean direct)`	Gets the named classes that are the direct or indirect domains of this property with respect to the imports closure of the root ontology.
`Set<OWLLiteral>`	`getDataPropertyValues(OWLNamedIndividual ind, OWLDataProperty pe)`	Gets the data property values for the specified individual and data property expression.
`EntityDescription<OWLClass>`	`getDescription(OWLClass owlClass)`	Returns the normalized semantic description of the specified class.
`EntityDescription<OWLNamedIndividual>`	`getDescription(OWLNamedIndividual individual)`	Returns the normalized semantic description of the specified individual.
`NodeSet<OWLNamedIndividual>`	`getDifferentIndividuals(OWLNamedIndividual ind)`	Gets the individuals which are entailed to be different from the specified individual.
`List<OWLClass>`	`getDirectSubClasses(OWLClass owlClass)`	Retrieves the direct subclasses of the specified class.
`List<OWLClass>`	`getDirectSuperClasses(OWLClass owlClass)`	Retrieves the direct superclasses of the specified class.
`NodeSet<OWLClass>`	`getDisjointClasses(OWLClassExpression ce)`	Gets the classes that are disjoint with the specified class expression `ce`.
`NodeSet<OWLDataProperty>`	`getDisjointDataProperties(OWLDataPropertyExpression pe)`	Gets the data properties that are disjoint with the specified data property expression `pe`.
`NodeSet<OWLObjectPropertyExpression>`	`getDisjointObjectProperties(OWLObjectPropertyExpression pe)`	Gets the simplified object property expressions that are disjoint with the specified object property expression `pe`.
`Node<OWLClass>`	`getEquivalentClasses(OWLClassExpression ce)`	Gets the set of named classes that are equivalent to the specified class expression with respect to the set of reasoner axioms.
`Node<OWLDataProperty>`	`getEquivalentDataProperties(OWLDataProperty pe)`	Gets the set of named data properties that are equivalent to the specified data property expression with respect to the imports closure of the root ontology.
`Node<OWLObjectPropertyExpression>`	`getEquivalentObjectProperties(OWLObjectPropertyExpression pe)`	Gets the set of simplified object property expressions that are equivalent to the specified object property expression with respect to the set of reasoner axioms.
`FreshEntityPolicy`	`getFreshEntityPolicy()`	Gets the Fresh Entity Policy in use by this reasoner.
`EntityDescription<OWLNamedIndividual>`	`getIndividualDescription(IRI iri)`	Refer to `getDescription(OWLNamedIndividual)`.
`IndividualNodeSetPolicy`	`getIndividualNodeSetPolicy()`	Gets the IndividualNodeSetPolicy in use by this reasoner.
`Stream<EntityDescription<OWLNamedIndividual>>`	`getIndividuals(IndividualType type)`	Retrieves all the individuals of a specified type.
`NodeSet<OWLNamedIndividual>`	`getInstances(OWLClassExpression ce, boolean direct)`	Gets the individuals which are instances of the specified class expression.
`Node<OWLObjectPropertyExpression>`	`getInverseObjectProperties(OWLObjectPropertyExpression pe)`	Gets the set of simplified object property expressions that are the inverses of the specified object property expression with respect to the imports closure of the root ontology.
`NodeSet<OWLClass>`	`getObjectPropertyDomains(OWLObjectPropertyExpression pe, boolean direct)`	Gets the named classes that are the direct or indirect domains of this property with respect to the imports closure of the root ontology.
`NodeSet<OWLClass>`	`getObjectPropertyRanges(OWLObjectPropertyExpression pe, boolean direct)`	Gets the named classes that are the direct or indirect ranges of this property with respect to the imports closure of the root ontology.
`NodeSet<OWLNamedIndividual>`	`getObjectPropertyValues(OWLNamedIndividual ind, OWLObjectPropertyExpression pe)`	Gets the object property values for the specified individual and object property expression.
`OWLOntology`	`getOntology()`	Returns the (root) ontology loaded into the reasoner.
`OWLDataFactory`	`getOWLDataFactory()`	Returns the OWL data factory of this reasoner.
`Set<OWLAxiom>`	`getPendingAxiomAdditions()`	Gets the axioms that as a result of ontology changes need to be added to the reasoner to synchronise it with the root ontology imports closure.
`Set<OWLAxiom>`	`getPendingAxiomRemovals()`	Gets the axioms that as a result of ontology changes need to removed to the reasoner to synchronise it with the root ontology imports closure.
`List<OWLOntologyChange>`	`getPendingChanges()`	Gets the pending changes which need to be taken into consideration by the reasoner so that it is up to date with the root ontology imports closure.
`Set<InferenceType>`	`getPrecomputableInferenceTypes()`	Returns the set of `InferenceType`s that are precomputable by reasoner.
`String`	`getReasonerInfo()`	Gets comprehensive reasoner info (multiline).
`String`	`getReasonerName()`	Gets the name of this reasoner.
`Version`	`getReasonerVersion()`	Gets the version of this reasoner.
`OWLOntology`	`getRootOntology()`	Gets the "root" ontology that is loaded into this reasoner.
`Node<OWLNamedIndividual>`	`getSameIndividuals(OWLNamedIndividual ind)`	Gets the individuals that are the same as the specified individual.
`NodeSet<OWLClass>`	`getSubClasses(OWLClassExpression ce, boolean direct)`	Gets the set of named classes that are the strict (potentially direct) subclasses of the specified class expression with respect to the reasoner axioms.
`NodeSet<OWLDataProperty>`	`getSubDataProperties(OWLDataProperty pe, boolean direct)`	Gets the set of named data properties that are the strict (potentially direct) subproperties of the specified data property expression with respect to the imports closure of the root ontology.
`NodeSet<OWLObjectPropertyExpression>`	`getSubObjectProperties(OWLObjectPropertyExpression pe, boolean direct)`	Gets the set of simplified object property expressions that are the strict (potentially direct) subproperties of the specified object property expression with respect to the imports closure of the root ontology.
`NodeSet<OWLClass>`	`getSuperClasses(OWLClassExpression ce, boolean direct)`	Gets the set of named classes that are the strict (potentially direct) super classes of the specified class expression with respect to the imports closure of the root ontology.
`NodeSet<OWLDataProperty>`	`getSuperDataProperties(OWLDataProperty pe, boolean direct)`	Gets the set of named data properties that are the strict (potentially direct) super properties of the specified data property with respect to the imports closure of the root ontology.
`NodeSet<OWLObjectPropertyExpression>`	`getSuperObjectProperties(OWLObjectPropertyExpression pe, boolean direct)`	Gets the set of simplified object property expressions that are the strict (potentially direct) super properties of the specified object property expression with respect to the imports closure of the root ontology.
`Stream<EntityDescription<OWLClass>>`	`getTBox()`	Returns the TBox loaded into this reasoner.
`long`	`getTimeOut()`	Gets the time out (in milliseconds) for the most basic reasoning operations.
`Node<OWLClass>`	`getTopClassNode()`	Gets the `Node` corresponding to the top node (containing `owl:Thing`) in the class hierarchy.
`Node<OWLDataProperty>`	`getTopDataPropertyNode()`	Gets the `Node` corresponding to the top node (containing `owl:topDataProperty`) in the data property hierarchy.
`Node<OWLObjectPropertyExpression>`	`getTopObjectPropertyNode()`	Gets the `Node` corresponding to the top node (containing `owl:topObjectProperty`) in the object property hierarchy.
`NodeSet<OWLClass>`	`getTypes(OWLNamedIndividual ind, boolean direct)`	Gets the named classes which are (potentially direct) types of the specified named individual.
`Node<OWLClass>`	`getUnsatisfiableClasses()`	A convenience method that obtains the classes in the signature of the root ontology that are unsatisfiable.
`void`	`interrupt()`	Asks the reasoner to interrupt what it is currently doing.
`boolean`	`isCoherent()`	Checks the coherence of the root ontology.
`boolean`	`isCompatible(SemanticDescription resource, SemanticDescription request)`	This method is the same as `isCompatible(OWLNamedIndividual, OWLNamedIndividual)`, with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
`boolean`	`isCompatible(IRI resourceIri, IRI requestIri)`	Refer to `isCompatible(OWLNamedIndividual, OWLNamedIndividual)`.
`boolean`	`isCompatible(OWLNamedIndividual resource, OWLNamedIndividual request)`	Determines if a supplied resource and a requested semantic profile are compatible (that is, whether the semantic description of the resource does not contain any information in conflict with the request).
`boolean`	`isConsistent()`	Determines if the set of reasoner axioms is consistent.
`boolean`	`isConsistent(IRI iri)`	Refer to `isConsistent(OWLNamedIndividual)`.
`boolean`	`isConsistent(OWLNamedIndividual individual)`	Checks whether the given individual is consistent.
`boolean`	`isEntailed(Set<? extends OWLAxiom> axioms)`	Determines if the specified set of axioms is entailed by the reasoner axioms.
`boolean`	`isEntailed(OWLAxiom axiom)`	A convenience method that determines if the specified axiom is entailed by the set of reasoner axioms.
`boolean`	`isEntailmentCheckingSupported(AxiomType<?> axiomType)`	Determines if entailment checking for the specified axiom type is supported.
`boolean`	`isInstance(OWLNamedIndividual individual, OWLClass owlClass)`	Checks whether the specified individual is an instance of a certain class.
`boolean`	`isPrecomputed(InferenceType inferenceType)`	Determines if a specific set of inferences have been precomputed.
`boolean`	`isSatisfiable(SemanticDescription description)`	Determines if the specified description is satisfiable with respect to the root ontology.
`boolean`	`isSatisfiable(OWLClassExpression ce)`	A convenience method that determines if the specified class expression is satisfiable with respect to the reasoner axioms.
`boolean`	`isSubClass(IRI subClassIri, IRI superClassIri)`	Refer to `isSubClass(OWLClass, OWLClass)`.
`boolean`	`isSubClass(OWLClass subClass, OWLClass superClass)`	Checks whether a subclass relation holds between two classes.
`boolean`	`isSubsumed(SemanticDescription subsumed, SemanticDescription subsumer)`	This method is the same as `isSubsumed(OWLNamedIndividual, OWLNamedIndividual)`, with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
`boolean`	`isSubsumed(IRI subsumedIri, IRI subsumerIri)`	Refer to `isSubsumed(OWLNamedIndividual, OWLNamedIndividual)`.
`boolean`	`isSubsumed(OWLNamedIndividual subsumed, OWLNamedIndividual subsumer)`	Determines if a subsumption relation holds between two semantic profiles (that is, if one is more general than the other), in which case they are referred to as subsumer and subsumed.
`Reasoner`	`loadIndividual(EntityDescription<OWLNamedIndividual> description, IndividualType type)`	Loads the specified individual into the reasoner as either a resource or a request.
`Reasoner`	`loadIndividuals(String ontologyPath, IndividualType type)`	Refer to `loadIndividuals(OWLOntology, IndividualType)`.
`Reasoner`	`loadIndividuals(OWLOntology ontology, IndividualType type)`	Loads the individuals present in the signature of the specified ontology.
`double`	`maxPenalty(SemanticDescription description)`	This method is the same as `maxPenalty(OWLNamedIndividual)`, with the difference that the provided description doesn't need to belong to an individual loaded into the reasoner.
`double`	`maxPenalty(IRI iri)`	Refer to `maxPenalty(OWLNamedIndividual)`.
`double`	`maxPenalty(OWLNamedIndividual individual)`	Computes the maximum penalty associated with the specified individual.
`SemanticDescription`	`normalize(SemanticDescription description)`	Performs the unfolding and CNF normalization of the specified semantic description.
`void`	`precomputeInferences(InferenceType... inferenceTypes)`	Asks the reasoner to precompute certain types of inferences.
`Reasoner`	`tellIndividualType(IRI iri, IndividualType type)`	Refer to `tellIndividualType(OWLNamedIndividual, IndividualType)`.
`Reasoner`	`tellIndividualType(OWLNamedIndividual individual, IndividualType type)`	Tells the reasoner that the individual is of the specified type.
`Reasoner`	`unloadIndividual(IRI iri)`	Refer to `unloadIndividual(OWLNamedIndividual)`.
`Reasoner`	`unloadIndividual(OWLNamedIndividual individual)`	Unloads the specified individual.
`Reasoner`	`unloadIndividuals(IndividualType type)`	Unloads all the individuals of a given type.
`Reasoner`	`unloadIndividuals(OWLOntology ontology)`	Unloads the individuals present in the signature of the specified ontology.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Details
- loadIndividual
  
  public Reasoner loadIndividual(EntityDescription<OWLNamedIndividual> description, IndividualType type)
  
  Loads the specified individual into the reasoner as either a resource or a request.
  
  Parameters:
  
  description - Description of the individual to load.
  
  type - Type of the individual to load (resource, request or both).
  
  Returns:
  
  This reasoner.
- loadIndividuals
  
  public Reasoner loadIndividuals(OWLOntology ontology, IndividualType type)
  
  Loads the individuals present in the signature of the specified ontology.
  
  Parameters:
  
  ontology - Ontology containing the individuals.
  
  type - Type of the loaded individuals (resource, request or both).
  
  Returns:
  
  This reasoner.
- loadIndividuals
  
  public Reasoner loadIndividuals(String ontologyPath, IndividualType type) throws OWLOntologyCreationException
  
  Refer to loadIndividuals(OWLOntology, IndividualType).
  
  Parameters:
  
  ontologyPath - Path of the ontology.
  
  type - Type of the individual (resource, request or both).
  
  Returns:
  
  This reasoner.
  
  Throws:
  
  OWLOntologyCreationException - If the ontology cannot be created.
- tellIndividualType
  
  public Reasoner tellIndividualType(OWLNamedIndividual individual, IndividualType type)
  
  Tells the reasoner that the individual is of the specified type.
  
  Parameters:
  
  individual - Individual whose type should be updated.
  
  type - Type of the individual (resource, request or both).
  
  Returns:
  
  This reasoner.
- tellIndividualType
  
  public Reasoner tellIndividualType(IRI iri, IndividualType type)
  
  Refer to tellIndividualType(OWLNamedIndividual, IndividualType).
  
  Parameters:
  
  iri - IRI of the individual.
  
  type - Type of the individual (resource, request or both).
  
  Returns:
  
  This reasoner.
- unloadIndividual
  
  public Reasoner unloadIndividual(OWLNamedIndividual individual)
  
  Unloads the specified individual.
  
  Parameters:
  
  individual - Individual to unload.
  
  Returns:
  
  This reasoner.
- unloadIndividual
  
  public Reasoner unloadIndividual(IRI iri)
  
  Refer to unloadIndividual(OWLNamedIndividual).
  
  Parameters:
  
  iri - IRI of the individual.
  
  Returns:
  
  This reasoner.
- unloadIndividuals
  
  public Reasoner unloadIndividuals(OWLOntology ontology)
  
  Unloads the individuals present in the signature of the specified ontology.
  
  Parameters:
  
  ontology - Ontology containing the individuals.
  
  Returns:
  
  This reasoner.
- unloadIndividuals
  
  public Reasoner unloadIndividuals(IndividualType type)
  
  Unloads all the individuals of a given type.
  
  Parameters:
  
  type - Type of the individuals to unload (resource, request or both).
  
  Returns:
  
  This reasoner.
- getOntology
  
  public OWLOntology getOntology()
  
  Returns the (root) ontology loaded into the reasoner.
  
  Returns:
  
  Ontology loaded into the reasoner.
- getDataFactory
  
  public DataFactory getDataFactory()
  
  Returns the data factory of this reasoner.
  
  Returns:
  
  DataFactory instance.
- getOWLDataFactory
  
  public OWLDataFactory getOWLDataFactory()
  
  Returns the OWL data factory of this reasoner.
  
  Returns:
  
  OWLDataFactory instance.
- getTBox
  
  public Stream<EntityDescription<OWLClass>> getTBox()
  
  Returns the TBox loaded into this reasoner.
  
  Returns:
  
  The TBox.
- getABox
  
  public Stream<EntityDescription<OWLNamedIndividual>> getABox()
  
  Returns the ABox loaded into this reasoner.
  
  Returns:
  
  The ABox.
- getIndividuals
  
  public Stream<EntityDescription<OWLNamedIndividual>> getIndividuals(IndividualType type)
  
  Retrieves all the individuals of a specified type.
  
  Parameters:
  
  type - Type of individuals to retrieve (resource, request or both).
  
  Returns:
  
  Individuals of the specified type.
- getDescription
  
  public EntityDescription<OWLClass> getDescription(OWLClass owlClass)
  
  Returns the normalized semantic description of the specified class.
  
  Parameters:
  
  owlClass - Class whose description should be retrieved.
  
  Returns:
  
  Description of the specified class.
- getDescription
  
  public EntityDescription<OWLNamedIndividual> getDescription(OWLNamedIndividual individual)
  
  Returns the normalized semantic description of the specified individual.
  
  Parameters:
  
  individual - Individual whose description should be retrieved.
  
  Returns:
  
  Description of the specified individual.
- getClassDescription
  
  public EntityDescription<OWLClass> getClassDescription(IRI iri)
  
  Refer to getDescription(OWLClass).
  
  Parameters:
  
  iri - IRI of the class.
  
  Returns:
  
  Description of the specified class.
- getIndividualDescription
  
  public EntityDescription<OWLNamedIndividual> getIndividualDescription(IRI iri)
  
  Refer to getDescription(OWLNamedIndividual).
  
  Parameters:
  
  iri - IRI of the individual.
  
  Returns:
  
  Description of the specified individual.
- classify
  
  public Reasoner classify()
  
  Computes the taxonomy of classes present in the root ontology.
  
  Returns:
  
  This reasoner.
- isCoherent
  
  public boolean isCoherent()
  
  Checks the coherence of the root ontology.
  
  Returns:
  
  True if the ontology is coherent, false otherwise.
  
  See Also:
  
  Moguillansky et al., IBERAMIA 2010.
- normalize
  
  public SemanticDescription normalize(SemanticDescription description)
  
  Performs the unfolding and CNF normalization of the specified semantic description. The description is mutated in-place and returned.
  
  Parameters:
  
  description - Semantic description to normalize.
  
  Returns:
  
  Normalized description.
- fold
  
  public SemanticDescription fold(SemanticDescription description)
  
  Folds the specified semantic description. The description is mutated in-place and returned.
  
  Parameters:
  
  description - Semantic description to fold.
  
  Returns:
  
  Folded description.
- isSubClass
  
  public boolean isSubClass(OWLClass subClass, OWLClass superClass)
  
  Checks whether a subclass relation holds between two classes.
  
  Parameters:
  
  subClass - Subclass.
  
  superClass - Superclass.
  
  Returns:
  
  True if the relation holds, false otherwise.
- isSubClass
  
  public boolean isSubClass(IRI subClassIri, IRI superClassIri)
  
  Refer to isSubClass(OWLClass, OWLClass).
  
  Parameters:
  
  subClassIri - IRI of the subclass.
  
  superClassIri - IRI of the superclass.
  
  Returns:
  
  True if the relation holds, false otherwise.
- getDirectSubClasses
  
  public List<OWLClass> getDirectSubClasses(OWLClass owlClass)
  
  Retrieves the direct subclasses of the specified class.
  
  Parameters:
  
  owlClass - Class whose subclasses should be retrieved.
  
  Returns:
  
  Direct subclasses.
- getDirectSuperClasses
  
  public List<OWLClass> getDirectSuperClasses(OWLClass owlClass)
  
  Retrieves the direct superclasses of the specified class.
  
  Parameters:
  
  owlClass - Class whose superclasses should be retrieved.
  
  Returns:
  
  Direct superclasses.
- isConsistent
  
  public boolean isConsistent(OWLNamedIndividual individual)
  
  Checks whether the given individual is consistent.
  
  Parameters:
  
  individual - Individual whose consistency should be checked.
  
  Returns:
  
  True if the individual is consistent, false otherwise.
- isConsistent
  
  public boolean isConsistent(IRI iri)
  
  Refer to isConsistent(OWLNamedIndividual).
  
  Parameters:
  
  iri - IRI of the individual.
  
  Returns:
  
  True if the individual is consistent, false otherwise.
- isSubsumed
  
  public boolean isSubsumed(OWLNamedIndividual subsumed, OWLNamedIndividual subsumer)
  Determines if a subsumption relation holds between two semantic profiles (that is, if one is more general than the other), in which case they are referred to as subsumer and subsumed. The profiles are OWL individuals previously loaded into the reasoner, either because they were present in the root ontology, or because they were loaded using the loadIndividuals(OWLOntology, IndividualType) and loadIndividual(EntityDescription, IndividualType) methods.
  If the subsumption relation holds, two conclusions can be drawn:
  
  The subsumer is more general than the subsumed, hence the former (usually a requested semantic profile) is satisfied by the latter (usually a supplied resource) in every aspect.
  
  The two elements involved in the relation are compatible.
  
  If the relation does not hold, abduction(OWLNamedIndividual, OWLNamedIndividual) may be used to compute what should be hypothesized in the subsumed individual in order to completely satisfy the subsumer individual.
  Parameters:
  
  subsumed - Subsumed element in the subsumption relation.
  
  subsumer - Subsumer element in the subsumption relation.
  
  Returns:
  
  True if the subsumption relation holds, false otherwise.
- isSubsumed
  
  public boolean isSubsumed(IRI subsumedIri, IRI subsumerIri)
  
  Refer to isSubsumed(OWLNamedIndividual, OWLNamedIndividual).
  
  Parameters:
  
  subsumedIri - IRI of the subsumed individual.
  
  subsumerIri - IRI of the subsumer individual.
  
  Returns:
  
  True if the subsumption relation holds, false otherwise.
- isSubsumed
  
  public boolean isSubsumed(SemanticDescription subsumed, SemanticDescription subsumer)
  
  This method is the same as isSubsumed(OWLNamedIndividual, OWLNamedIndividual), with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
  
  Parameters:
  
  subsumed - Subsumed description.
  
  subsumer - Subsumer description.
  
  Returns:
  
  True if the subsumption relation holds, false otherwise.
- isInstance
  
  public boolean isInstance(OWLNamedIndividual individual, OWLClass owlClass)
  
  Checks whether the specified individual is an instance of a certain class.
  
  Parameters:
  
  individual - Individual.
  
  owlClass - Class.
  
  Returns:
  
  True if the individual is an instance of the class, false otherwise.
  
  API Note:
  
  This is currently incomplete since the reasoner does not process the ABox.
- isCompatible
  
  public boolean isCompatible(OWLNamedIndividual resource, OWLNamedIndividual request)
  
  Determines if a supplied resource and a requested semantic profile are compatible (that is, whether the semantic description of the resource does not contain any information in conflict with the request). Resource and request are OWL individuals previously loaded into the reasoner, either because they were present in the root ontology, or because they were loaded using the loadIndividuals(OWLOntology, IndividualType) and loadIndividual(EntityDescription, IndividualType) methods.
  If the compatibility relation between the two individuals holds, then they don't contain any conflicting part. If the relation does not hold, contraction(OWLNamedIndividual, OWLNamedIndividual) may be used to compute the conflicting part.
  
  Parameters:
  
  resource - Resource individual.
  
  request - Request individual.
  
  Returns:
  
  True if the compatibility relation holds, false otherwise.
- isCompatible
  
  public boolean isCompatible(IRI resourceIri, IRI requestIri)
  
  Refer to isCompatible(OWLNamedIndividual, OWLNamedIndividual).
  
  Parameters:
  
  resourceIri - IRI of the resource.
  
  requestIri - IRI of the request.
  
  Returns:
  
  True if the compatibility relation holds, false otherwise.
- isCompatible
  
  public boolean isCompatible(SemanticDescription resource, SemanticDescription request)
  
  This method is the same as isCompatible(OWLNamedIndividual, OWLNamedIndividual), with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
  
  Parameters:
  
  resource - Resource description.
  
  request - Request description.
  
  Returns:
  
  True if the compatibility relation holds, false otherwise.
- abduction
  
  public Abduction abduction(OWLNamedIndividual resource, OWLNamedIndividual request)
  
  Performs the Concept Abduction non-standard matchmaking task, comparing a requested semantic profile with a supplied resource. Resource and request are OWL individuals previously loaded into the reasoner, either because they were present in the root ontology, or because they were loaded using the loadIndividuals(OWLOntology, IndividualType) and loadIndividual(EntityDescription, IndividualType) methods.
  
  Parameters:
  
  resource - Resource.
  
  request - Request.
  
  Returns:
  
  Result of the abduction inference service.
  
  See Also:
  
  Ruta et al., WIAS 2011 (Section 4, Chapter 2) for a technical description of the Concept Abduction Problem.
- abduction
  
  public Abduction abduction(IRI resourceIri, IRI requestIri)
  
  Refer to abduction(OWLNamedIndividual, OWLNamedIndividual).
  
  Parameters:
  
  resourceIri - IRI of the resource individual.
  
  requestIri - IRI of the request individual.
  
  Returns:
  
  Result of the abduction inference service.
- abduction
  
  public Abduction abduction(SemanticDescription resource, SemanticDescription request)
  
  This method is the same as abduction(OWLNamedIndividual, OWLNamedIndividual), with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
  
  Parameters:
  
  resource - Resource description.
  
  request - Request description.
  
  Returns:
  
  Result of the abduction inference service.
- bonus
  
  public Bonus bonus(OWLNamedIndividual resource, OWLNamedIndividual request)
  
  Performs the Concept Bonus non-standard matchmaking task, comparing a requested semantic profile with a supplied resource. Resource and request are OWL individuals previously loaded into the reasoner, either because they were present in the root ontology, or because they were loaded using the loadIndividuals(OWLOntology, IndividualType) and loadIndividual(EntityDescription, IndividualType) methods.
  
  Parameters:
  
  resource - Resource.
  
  request - Request.
  
  Returns:
  
  Result of the bonus inference service.
  
  See Also:
  
  Scioscia et al., SRLGIPD18 for a technical description of the Concept Bonus Problem.
- bonus
  
  public Bonus bonus(IRI resourceIri, IRI requestIri)
  
  Refer to bonus(OWLNamedIndividual, OWLNamedIndividual).
  
  Parameters:
  
  resourceIri - IRI of the resource individual.
  
  requestIri - IRI of the request individual.
  
  Returns:
  
  Result of the bonus inference service.
- bonus
  
  public Bonus bonus(SemanticDescription resource, SemanticDescription request)
  
  This method is the same as bonus(OWLNamedIndividual, OWLNamedIndividual), with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
  
  Parameters:
  
  resource - Resource description.
  
  request - Request description.
  
  Returns:
  
  Result of the bonus inference service.
- contraction
  
  public Contraction contraction(OWLNamedIndividual resource, OWLNamedIndividual request)
  
  Performs the Concept Contraction non-standard matchmaking task, comparing a requested semantic profile with a supplied resource. Resource and request are OWL individuals previously loaded into the reasoner, either because they were present in the root ontology, or because they were loaded using the loadIndividuals(OWLOntology, IndividualType) and loadIndividual(EntityDescription, IndividualType) methods.
  
  Parameters:
  
  resource - Resource individual.
  
  request - Request individual.
  
  Returns:
  
  Result of the contraction inference service.
  
  See Also:
  
  Ruta et al., WIAS 2011 (Section 4, Chapter 2) for a technical description of the Concept Contraction Problem.
- contraction
  
  public Contraction contraction(IRI resourceIri, IRI requestIri)
  
  Refer to contraction(OWLNamedIndividual, OWLNamedIndividual).
  
  Parameters:
  
  resourceIri - IRI of the resource individual.
  
  requestIri - IRI of the request individual.
  
  Returns:
  
  Result of the contraction inference service.
- contraction
  
  public Contraction contraction(SemanticDescription resource, SemanticDescription request)
  
  This method is the same as contraction(OWLNamedIndividual, OWLNamedIndividual), with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
  
  Parameters:
  
  resource - Resource description.
  
  request - Request description.
  
  Returns:
  
  Result of the contraction inference service.
- covering
  
  public Composition covering(OWLNamedIndividual request)
  
  Performs the Concept Covering non-standard matchmaking task, comparing a requested semantic profile with available resources. Request is an OWL individuals previously loaded into the reasoner using the loadIndividuals(OWLOntology, IndividualType) and loadIndividual(EntityDescription, IndividualType) methods.
  
  Parameters:
  
  request - Request.
  
  Returns:
  
  Result of the covering inference service.
  
  See Also:
  
  Di Noia et al., Concept Covering for a technical description of the Concept Covering Problem.
- covering
  
  public Composition covering(IRI iri)
  
  Refer to covering(OWLNamedIndividual).
  
  Parameters:
  
  iri - IRI of the request individual.
  
  Returns:
  
  Result of the covering inference service.
- covering
  
  public Composition covering(SemanticDescription request)
  
  This method is the same as covering(OWLNamedIndividual), with the difference that the provided description doesn't need to belong to an individual loaded into the reasoner.
  
  Parameters:
  
  request - Request description.
  
  Returns:
  
  Result of the covering inference service.
- isSatisfiable
  
  public boolean isSatisfiable(SemanticDescription description)
  
  Determines if the specified description is satisfiable with respect to the root ontology.
  
  Parameters:
  
  description - Description whose satisfiability should be checked.
  
  Returns:
  
  True if the description is satisfiable, false otherwise.
- difference
  
  public SemanticDescription difference(OWLNamedIndividual lhs, OWLNamedIndividual rhs)
  
  Computes the Concept Difference between two individuals.
  
  Parameters:
  
  lhs - LHS of the difference.
  
  rhs - RHS of the difference.
  
  Returns:
  
  Result of the difference task.
- difference
  
  public SemanticDescription difference(IRI lhs, IRI rhs)
  
  Refer to difference(OWLNamedIndividual, OWLNamedIndividual).
  
  Parameters:
  
  lhs - IRI of the LHS individual.
  
  rhs - IRI of the RHS individual.
  
  Returns:
  
  Result of the difference task.
- difference
  
  public SemanticDescription difference(SemanticDescription lhs, SemanticDescription rhs)
  
  This method is the same as difference(OWLNamedIndividual, OWLNamedIndividual), with the difference that the provided descriptions don't need to belong to individuals loaded into the reasoner.
  
  Parameters:
  
  lhs - LHS of the difference.
  
  rhs - RHS of the difference.
  
  Returns:
  
  Result of the difference task.
- maxPenalty
  
  public double maxPenalty(OWLNamedIndividual individual)
  
  Computes the maximum penalty associated with the specified individual.
  
  Parameters:
  
  individual - Individual.
  
  Returns:
  
  Maximum penalty.
- maxPenalty
  
  public double maxPenalty(IRI iri)
  
  Refer to maxPenalty(OWLNamedIndividual).
  
  Parameters:
  
  iri - IRI of the individual.
  
  Returns:
  
  Maximum penalty.
- maxPenalty
  
  public double maxPenalty(SemanticDescription description)
  
  This method is the same as maxPenalty(OWLNamedIndividual), with the difference that the provided description doesn't need to belong to an individual loaded into the reasoner.
  
  Parameters:
  
  description - Semantic description.
  
  Returns:
  
  Maximum penalty.
- getReasonerInfo
  
  public String getReasonerInfo()
  
  Gets comprehensive reasoner info (multiline).
  
  Returns:
  
  A string containing info about this reasoner.
- getReasonerName
  
  public String getReasonerName()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the name of this reasoner.
  
  Specified by:
  
  getReasonerName in interface OWLReasoner
  
  Returns:
  
  A string that represents the name of this reasoner.
- getReasonerVersion
  
  public Version getReasonerVersion()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the version of this reasoner.
  
  Specified by:
  
  getReasonerVersion in interface OWLReasoner
  
  Returns:
  
  The version of this reasoner. Not null.
- getBufferingMode
  
  public BufferingMode getBufferingMode()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the buffering mode of this reasoner.
  
  Specified by:
  
  getBufferingMode in interface OWLReasoner
  
  Returns:
  
  The buffering mode of this reasoner.
- flush
  
  public void flush()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Flushes any changes stored in the buffer, which causes the reasoner to take into consideration the changes the current root ontology specified by the changes. If the reasoner buffering mode is BufferingMode.NON_BUFFERING then this method will have no effect.
  
  Specified by:
  
  flush in interface OWLReasoner
- getPendingChanges
  
  public List<OWLOntologyChange> getPendingChanges()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the pending changes which need to be taken into consideration by the reasoner so that it is up to date with the root ontology imports closure. After the OWLReasoner.flush() method is called the set of pending changes will be empty.
  
  Specified by:
  
  getPendingChanges in interface OWLReasoner
  
  Returns:
  
  A set of changes. Note that the changes represent the raw changes as applied to the imports closure of the root ontology.
- getPendingAxiomAdditions
  
  public Set<OWLAxiom> getPendingAxiomAdditions()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the axioms that as a result of ontology changes need to be added to the reasoner to synchronise it with the root ontology imports closure. If the buffering mode is BufferingMode.NON_BUFFERING then there will be no pending axiom additions.
  
  Specified by:
  
  getPendingAxiomAdditions in interface OWLReasoner
  
  Returns:
  
  The set of axioms that need to added to the reasoner to the reasoner to synchronise it with the root ontology imports closure.
- getPendingAxiomRemovals
  
  public Set<OWLAxiom> getPendingAxiomRemovals()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the axioms that as a result of ontology changes need to removed to the reasoner to synchronise it with the root ontology imports closure. If the buffering mode is BufferingMode.NON_BUFFERING then there will be no pending axiom additions.
  
  Specified by:
  
  getPendingAxiomRemovals in interface OWLReasoner
  
  Returns:
  
  The set of axioms that need to added to the reasoner to the reasoner to synchronise it with the root ontology imports closure.
- getRootOntology
  
  public OWLOntology getRootOntology()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the "root" ontology that is loaded into this reasoner. The reasoner takes into account the axioms in this ontology and its imports closure, plus the axioms returned by OWLReasoner.getPendingAxiomRemovals(), minus the axioms returned by OWLReasoner.getPendingAxiomAdditions() when reasoning.
  Note that the root ontology is set at reasoner creation time and cannot be changed thereafter. Clients that want to add ontologies to and remove ontologies from the reasoner after creation time should create a "dummy" ontology that imports the "real" ontologies and then specify the dummy ontology as the root ontology at reasoner creation time.
  
  Specified by:
  
  getRootOntology in interface OWLReasoner
  
  Returns:
  
  The root ontology that is loaded into the reasoner.
- interrupt
  
  public void interrupt()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Asks the reasoner to interrupt what it is currently doing. An ReasonerInterruptedException will be thrown in the thread that invoked the last reasoner operation. The OWL API is not thread safe in general, but it is likely that this method will be called from another thread than the event dispatch thread or the thread in which reasoning takes place.
  Note that the reasoner will periodically check for interupt requests. Asking the reasoner to interrupt the current process does not mean that it will be interrupted immediately. However, clients can expect to be able to interupt individual consistency checks, satisfiability checks etc.
  
  Specified by:
  
  interrupt in interface OWLReasoner
- precomputeInferences
  
  public void precomputeInferences(InferenceType... inferenceTypes)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Asks the reasoner to precompute certain types of inferences. Note that it is NOT necessary to call this method before asking any other queries - the reasoner will answer all queries correctly regardless of whether inferences are precomputed or not. For example, if the imports closure of the root ontology entails SubClassOf(A B) then the result of getSubClasses(B) will contain A, regardless of whether precomputeInferences( InferenceType#CLASS_HIERARCHY) has been called.
  If the reasoner does not support the precomputation of a particular type of inference then it will silently ignore the request.
  
  Specified by:
  
  precomputeInferences in interface OWLReasoner
  
  Parameters:
  
  inferenceTypes - Suggests a list of the types of inferences that should be precomputed. If the list is empty then the reasoner will determine which types of inferences are precomputed. Note that the order of the list is unimportant - the reasoner will determine the order in which inferences are computed.
- isPrecomputed
  
  public boolean isPrecomputed(InferenceType inferenceType)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Determines if a specific set of inferences have been precomputed.
  
  Specified by:
  
  isPrecomputed in interface OWLReasoner
  
  Parameters:
  
  inferenceType - The type of inference to check for.
  
  Returns:
  
  true if the specified type of inferences have been precomputed, otherwise false.
- getPrecomputableInferenceTypes
  
  public Set<InferenceType> getPrecomputableInferenceTypes()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Returns the set of InferenceTypes that are precomputable by reasoner.
  
  Specified by:
  
  getPrecomputableInferenceTypes in interface OWLReasoner
  
  Returns:
  
  A set of InferenceTypes that can be precomputed by this reasoner.
- isConsistent
  
  public boolean isConsistent()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Determines if the set of reasoner axioms is consistent. Note that this method will NOT throw an InconsistentOntologyException even if the root ontology imports closure is inconsistent.
  
  Specified by:
  
  isConsistent in interface OWLReasoner
  
  Returns:
  
  true if the imports closure of the root ontology is consistent, or false if the imports closure of the root ontology is inconsistent.
- isSatisfiable
  
  public boolean isSatisfiable(OWLClassExpression ce) throws ClassExpressionNotInProfileException
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  A convenience method that determines if the specified class expression is satisfiable with respect to the reasoner axioms.
  
  Specified by:
  
  isSatisfiable in interface OWLReasoner
  
  Parameters:
  
  ce - The class expression
  
  Returns:
  
  true if classExpression is satisfiable with respect to the set of axioms, or false if classExpression is unsatisfiable with respect to the axioms.
  
  Throws:
  
  ClassExpressionNotInProfileException - if classExpression is not within the profile that is supported by this reasoner.
- getUnsatisfiableClasses
  
  public Node<OWLClass> getUnsatisfiableClasses()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  A convenience method that obtains the classes in the signature of the root ontology that are unsatisfiable.
  
  Specified by:
  
  getUnsatisfiableClasses in interface OWLReasoner
  
  Returns:
  
  A Node that is the bottom node in the class hierarchy. This node represents owl:Nothing and contains owl:Nothing itself plus classes that are equivalent to owl:Nothing.
- isEntailed
  
  public boolean isEntailed(OWLAxiom axiom) throws UnsupportedEntailmentTypeException
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  A convenience method that determines if the specified axiom is entailed by the set of reasoner axioms.
  
  Specified by:
  
  isEntailed in interface OWLReasoner
  
  Parameters:
  
  axiom - The axiom
  
  Returns:
  
  true if axiom is entailed by the reasoner axioms or false if axiom is not entailed by the reasoner axioms. true if the set of reasoner axioms is inconsistent.
  
  Throws:
  
  UnsupportedEntailmentTypeException - if the reasoner cannot perform a check to see if the specified axiom is entailed
  
  See Also:
  
  OWLReasoner.isEntailmentCheckingSupported(org.semanticweb.owlapi.model.AxiomType)
- isEntailed
  
  public boolean isEntailed(Set<? extends OWLAxiom> axioms) throws UnsupportedEntailmentTypeException
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Determines if the specified set of axioms is entailed by the reasoner axioms.
  
  Specified by:
  
  isEntailed in interface OWLReasoner
  
  Parameters:
  
  axioms - The set of axioms to be tested
  
  Returns:
  
  true if the set of axioms is entailed by the axioms in the imports closure of the root ontology, otherwise false . If the set of reasoner axioms is inconsistent then true .
  
  Throws:
  
  UnsupportedEntailmentTypeException - if the reasoner cannot perform a check to see if the specified axiom is entailed
  
  See Also:
  
  OWLReasoner.isEntailmentCheckingSupported(org.semanticweb.owlapi.model.AxiomType)
- isEntailmentCheckingSupported
  
  public boolean isEntailmentCheckingSupported(AxiomType<?> axiomType)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Determines if entailment checking for the specified axiom type is supported.
  
  Specified by:
  
  isEntailmentCheckingSupported in interface OWLReasoner
  
  Parameters:
  
  axiomType - The axiom type
  
  Returns:
  
  true if entailment checking for the specified axiom type is supported, otherwise false. If true then asking OWLReasoner.isEntailed(org.semanticweb.owlapi.model.OWLAxiom) will not throw an exception of UnsupportedEntailmentTypeException . If false then asking OWLReasoner.isEntailed(org.semanticweb.owlapi.model.OWLAxiom) will throw an UnsupportedEntailmentTypeException .
- getTopClassNode
  
  public Node<OWLClass> getTopClassNode()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the Node corresponding to the top node (containing owl:Thing) in the class hierarchy.
  
  Specified by:
  
  getTopClassNode in interface OWLReasoner
  
  Returns:
  
  A Node containing owl:Thing that is the top node in the class hierarchy. This Node is essentially equal to the Node returned by calling OWLReasoner.getEquivalentClasses(org.semanticweb.owlapi.model.OWLClassExpression) with a parameter of owl:Thing.
- getBottomClassNode
  
  public Node<OWLClass> getBottomClassNode()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the Node corresponding to the bottom node (containing owl:Nothing) in the class hierarchy.
  
  Specified by:
  
  getBottomClassNode in interface OWLReasoner
  
  Returns:
  
  A Node containing owl:Nothing that is the bottom node in the class hierarchy. This Node is essentially equal to the Node that will be returned by calling OWLReasoner.getEquivalentClasses(org.semanticweb.owlapi.model.OWLClassExpression) with a parameter of owl:Nothing.
- getSubClasses
  
  public NodeSet<OWLClass> getSubClasses(OWLClassExpression ce, boolean direct) throws ClassExpressionNotInProfileException
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the set of named classes that are the strict (potentially direct) subclasses of the specified class expression with respect to the reasoner axioms. Note that the classes are returned as a NodeSet.
  
  Specified by:
  
  getSubClasses in interface OWLReasoner
  
  Parameters:
  
  ce - The class expression whose strict (direct) subclasses are to be retrieved.
  
  direct - Specifies if the direct subclasses should be retrived ( true) or if the all subclasses (descendant) classes should be retrieved (false).
  
  Returns:
  
  If direct is true, a NodeSet such that for each class C in the NodeSet the set of reasoner axioms entails DirectSubClassOf(C, ce).
  If direct is false, a NodeSet such that for each class C in the NodeSet the set of reasoner axioms entails StrictSubClassOf(C, ce).
  If ce is equivalent to owl:Nothing then the empty NodeSet will be returned.
  
  Throws:
  
  ClassExpressionNotInProfileException - if classExpression is not within the profile that is supported by this reasoner.
- getSuperClasses
  
  public NodeSet<OWLClass> getSuperClasses(OWLClassExpression ce, boolean direct) throws ClassExpressionNotInProfileException
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the set of named classes that are the strict (potentially direct) super classes of the specified class expression with respect to the imports closure of the root ontology. Note that the classes are returned as a NodeSet.
  
  Specified by:
  
  getSuperClasses in interface OWLReasoner
  
  Parameters:
  
  ce - The class expression whose strict (direct) super classes are to be retrieved.
  
  direct - Specifies if the direct super classes should be retrived ( true) or if the all super classes (ancestors) classes should be retrieved (false).
  
  Returns:
  
  If direct is true, a NodeSet such that for each class C in the NodeSet the set of reasoner axioms entails DirectSubClassOf(ce, C).
  If direct is false, a NodeSet such that for each class C in the NodeSet the set of reasoner axioms entails StrictSubClassOf(ce, C).
  If ce is equivalent to owl:Thing then the empty NodeSet will be returned.
  
  Throws:
  
  ClassExpressionNotInProfileException - if classExpression is not within the profile that is supported by this reasoner.
- getEquivalentClasses
  
  public Node<OWLClass> getEquivalentClasses(OWLClassExpression ce) throws ClassExpressionNotInProfileException
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the set of named classes that are equivalent to the specified class expression with respect to the set of reasoner axioms. The classes are returned as a Node.
  
  Specified by:
  
  getEquivalentClasses in interface OWLReasoner
  
  Parameters:
  
  ce - The class expression whose equivalent classes are to be retrieved.
  
  Returns:
  
  A node containing the named classes such that for each named class C in the node the root ontology imports closure entails EquivalentClasses(ce C). If ce is not a class name (i.e. it is an anonymous class expression) and there are no such classes C then the node will be empty.
  If ce is a named class then ce will be contained in the node.
  If ce is unsatisfiable with respect to the set of reasoner axioms then the node representing and containing owl:Nothing, i.e. the bottom node, will be returned.
  If ce is equivalent to owl:Thing with respect to the set of reasoner axioms then the node representing and containing owl:Thing, i.e. the top node, will be returned
  .
  
  Throws:
  
  ClassExpressionNotInProfileException - if classExpression is not within the profile that is supported by this reasoner.
- getDisjointClasses
  
  public NodeSet<OWLClass> getDisjointClasses(OWLClassExpression ce) throws ClassExpressionNotInProfileException
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the classes that are disjoint with the specified class expression ce. The classes are returned as a NodeSet.
  
  Specified by:
  
  getDisjointClasses in interface OWLReasoner
  
  Parameters:
  
  ce - The class expression whose disjoint classes are to be retrieved.
  
  Returns:
  
  The return value is a NodeSet such that for each class D in the NodeSet the set of reasoner axioms entails EquivalentClasses(D, ObjectComplementOf(ce)) or StrictSubClassOf(D, ObjectComplementOf(ce)).
  
  Throws:
  
  ClassExpressionNotInProfileException - if classExpression is not within the profile that is supported by this reasoner.
- getTopObjectPropertyNode
  
  public Node<OWLObjectPropertyExpression> getTopObjectPropertyNode()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the Node corresponding to the top node (containing owl:topObjectProperty) in the object property hierarchy.
  
  Specified by:
  
  getTopObjectPropertyNode in interface OWLReasoner
  
  Returns:
  
  A Node containing owl:topObjectProperty that is the top node in the object property hierarchy. This Node is essentially equivalent to the Node returned by calling OWLReasoner.getEquivalentObjectProperties(org.semanticweb.owlapi.model.OWLObjectPropertyExpression) with a parameter of owl:topObjectProperty.
- getBottomObjectPropertyNode
  
  public Node<OWLObjectPropertyExpression> getBottomObjectPropertyNode()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the Node corresponding to the bottom node (containing owl:bottomObjectProperty) in the object property hierarchy.
  
  Specified by:
  
  getBottomObjectPropertyNode in interface OWLReasoner
  
  Returns:
  
  A Node, containing owl:bottomObjectProperty, that is the bottom node in the object property hierarchy. This Node is essentially equal to the Node that will be returned by calling OWLReasoner.getEquivalentObjectProperties(org.semanticweb.owlapi.model.OWLObjectPropertyExpression) with a parameter of owl:bottomObjectProperty.
- getSubObjectProperties
  
  public NodeSet<OWLObjectPropertyExpression> getSubObjectProperties(OWLObjectPropertyExpression pe, boolean direct)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the set of simplified object property expressions that are the strict (potentially direct) subproperties of the specified object property expression with respect to the imports closure of the root ontology. Note that the properties are returned as a NodeSet.
  
  Specified by:
  
  getSubObjectProperties in interface OWLReasoner
  
  Parameters:
  
  pe - The object property expression whose strict (direct) subproperties are to be retrieved.
  
  direct - Specifies if the direct subproperties should be retrived ( true) or if the all subproperties (descendants) should be retrieved (false).
  
  Returns:
  
  If direct is true, a NodeSet of simplified object property expressions, such that for each simplified object property expression, P, in the NodeSet the set of reasoner axioms entails DirectSubObjectPropertyOf(P, pe).
  If direct is false, a NodeSet of simplified object property expressions, such that for each simplified object property expression, P, in the NodeSet the set of reasoner axioms entails StrictSubObjectPropertyOf(P, pe).
  If pe is equivalent to owl:bottomObjectProperty then the empty NodeSet will be returned.
- getSuperObjectProperties
  
  public NodeSet<OWLObjectPropertyExpression> getSuperObjectProperties(OWLObjectPropertyExpression pe, boolean direct)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the set of simplified object property expressions that are the strict (potentially direct) super properties of the specified object property expression with respect to the imports closure of the root ontology. Note that the properties are returned as a NodeSet.
  
  Specified by:
  
  getSuperObjectProperties in interface OWLReasoner
  
  Parameters:
  
  pe - The object property expression whose strict (direct) super properties are to be retrieved.
  
  direct - Specifies if the direct super properties should be retrived ( true) or if the all super properties (ancestors) should be retrieved (false).
  
  Returns:
  
  If direct is true, a NodeSet of simplified object property expressions, such that for each simplified object property expression, P, in the NodeSet, the set of reasoner axioms entails DirectSubObjectPropertyOf(pe, P).
  If direct is false, a NodeSet of simplified object property expressions, such that for each simplified object property expression, P, in the NodeSet, the set of reasoner axioms entails StrictSubObjectPropertyOf(pe, P).
  If pe is equivalent to owl:topObjectProperty then the empty NodeSet will be returned.
- getEquivalentObjectProperties
  
  public Node<OWLObjectPropertyExpression> getEquivalentObjectProperties(OWLObjectPropertyExpression pe)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the set of simplified object property expressions that are equivalent to the specified object property expression with respect to the set of reasoner axioms. The properties are returned as a Node.
  
  Specified by:
  
  getEquivalentObjectProperties in interface OWLReasoner
  
  Parameters:
  
  pe - The object property expression whose equivalent properties are to be retrieved.
  
  Returns:
  
  A node containing the simplified object property expressions such that for each simplified object property expression, P, in the node, the set of reasoner axioms entails EquivalentObjectProperties(pe P).
  If pe is a simplified object property expression If pe is unsatisfiable with respect to the set of reasoner axioms then the node representing and containing owl:bottomObjectProperty, i.e. the bottom node, will be returned.
  If pe is equivalent to owl:topObjectProperty with respect to the set of reasoner axioms then the node representing and containing owl:topObjectProperty, i.e. the top node, will be returned
  .
- getDisjointObjectProperties
  
  public NodeSet<OWLObjectPropertyExpression> getDisjointObjectProperties(OWLObjectPropertyExpression pe)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the simplified object property expressions that are disjoint with the specified object property expression pe. The object properties are returned as a NodeSet.
  
  Specified by:
  
  getDisjointObjectProperties in interface OWLReasoner
  
  Parameters:
  
  pe - The object property expression whose disjoint object properties are to be retrieved.
  
  Returns:
  
  The return value is a NodeSet of simplified object property expressions, such that for each simplified object property expression, P, in the NodeSet the set of reasoner axioms entails EquivalentObjectProperties(P, ObjectPropertyComplementOf(pe)) or StrictSubObjectPropertyOf(P, ObjectPropertyComplementOf(pe)) .
- getInverseObjectProperties
  
  public Node<OWLObjectPropertyExpression> getInverseObjectProperties(OWLObjectPropertyExpression pe)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the set of simplified object property expressions that are the inverses of the specified object property expression with respect to the imports closure of the root ontology. The properties are returned as a NodeSet
  
  Specified by:
  
  getInverseObjectProperties in interface OWLReasoner
  
  Parameters:
  
  pe - The property expression whose inverse properties are to be retrieved.
  
  Returns:
  
  A NodeSet of simplified object property expressions, such that for each simplified object property expression P in the nodes set, the set of reasoner axioms entails InverseObjectProperties(pe, P).
- getObjectPropertyDomains
  
  public NodeSet<OWLClass> getObjectPropertyDomains(OWLObjectPropertyExpression pe, boolean direct)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the named classes that are the direct or indirect domains of this property with respect to the imports closure of the root ontology. The classes are returned as a NodeSet .
  
  Specified by:
  
  getObjectPropertyDomains in interface OWLReasoner
  
  Parameters:
  
  pe - The property expression whose domains are to be retrieved.
  
  direct - Specifies if the direct domains should be retrieved ( true), or if all domains should be retrieved ( false).
  
  Returns:
  
  Let N = getEquivalentClasses(ObjectSomeValuesFrom(pe owl:Thing)) .
  If direct is true: then if N is not empty then the return value is N, else the return value is the result of getSuperClasses(ObjectSomeValuesFrom(pe owl:Thing), true) .
  If direct is false: then the result of getSuperClasses(ObjectSomeValuesFrom(pe owl:Thing), false) together with N if N is non-empty.
- getObjectPropertyRanges
  
  public NodeSet<OWLClass> getObjectPropertyRanges(OWLObjectPropertyExpression pe, boolean direct)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the named classes that are the direct or indirect ranges of this property with respect to the imports closure of the root ontology. The classes are returned as a NodeSet .
  
  Specified by:
  
  getObjectPropertyRanges in interface OWLReasoner
  
  Parameters:
  
  pe - The property expression whose ranges are to be retrieved.
  
  direct - Specifies if the direct ranges should be retrieved ( true), or if all ranges should be retrieved ( false).
  
  Returns:
  
  Let N = getEquivalentClasses(ObjectSomeValuesFrom(ObjectInverseOf(pe) owl:Thing)) .
  If direct is true: then if N is not empty then the return value is N, else the return value is the result of getSuperClasses(ObjectSomeValuesFrom(ObjectInverseOf(pe) owl:Thing), true) .
  If direct is false: then the result of getSuperClasses(ObjectSomeValuesFrom(ObjectInverseOf(pe) owl:Thing), false) together with N if N is non-empty.
- getTopDataPropertyNode
  
  public Node<OWLDataProperty> getTopDataPropertyNode()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the Node corresponding to the top node (containing owl:topDataProperty) in the data property hierarchy.
  
  Specified by:
  
  getTopDataPropertyNode in interface OWLReasoner
  
  Returns:
  
  A Node, containing owl:topDataProperty, that is the top node in the data property hierarchy. This Node is essentially equal to the Node returned by calling OWLReasoner.getEquivalentDataProperties(org.semanticweb.owlapi.model.OWLDataProperty) with a parameter of owl:topDataProperty.
- getBottomDataPropertyNode
  
  public Node<OWLDataProperty> getBottomDataPropertyNode()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the Node corresponding to the bottom node (containing owl:bottomDataProperty) in the data property hierarchy.
  
  Specified by:
  
  getBottomDataPropertyNode in interface OWLReasoner
  
  Returns:
  
  A Node, containing owl:bottomDataProperty, that is the bottom node in the data property hierarchy. This Node is essentially equal to the Node that will be returned by calling OWLReasoner.getEquivalentDataProperties(org.semanticweb.owlapi.model.OWLDataProperty) with a parameter of owl:bottomDataProperty.
- getSubDataProperties
  
  public NodeSet<OWLDataProperty> getSubDataProperties(OWLDataProperty pe, boolean direct)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the set of named data properties that are the strict (potentially direct) subproperties of the specified data property expression with respect to the imports closure of the root ontology. Note that the properties are returned as a NodeSet.
  
  Specified by:
  
  getSubDataProperties in interface OWLReasoner
  
  Parameters:
  
  pe - The data property whose strict (direct) subproperties are to be retrieved.
  
  direct - Specifies if the direct subproperties should be retrived ( true) or if the all subproperties (descendants) should be retrieved (false).
  
  Returns:
  
  If direct is true, a NodeSet such that for each property P in the NodeSet the set of reasoner axioms entails DirectSubDataPropertyOf(P, pe).
  If direct is false, a NodeSet such that for each property P in the NodeSet the set of reasoner axioms entails StrictSubDataPropertyOf(P, pe).
  If pe is equivalent to owl:bottomDataProperty then the empty NodeSet will be returned.
- getSuperDataProperties
  
  public NodeSet<OWLDataProperty> getSuperDataProperties(OWLDataProperty pe, boolean direct)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the set of named data properties that are the strict (potentially direct) super properties of the specified data property with respect to the imports closure of the root ontology. Note that the properties are returned as a NodeSet.
  
  Specified by:
  
  getSuperDataProperties in interface OWLReasoner
  
  Parameters:
  
  pe - The data property whose strict (direct) super properties are to be retrieved.
  
  direct - Specifies if the direct super properties should be retrived ( true) or if the all super properties (ancestors) should be retrieved (false).
  
  Returns:
  
  If direct is true, a NodeSet such that for each property P in the NodeSet the set of reasoner axioms entails DirectSubDataPropertyOf(pe, P).
  If direct is false, a NodeSet such that for each property P in the NodeSet the set of reasoner axioms entails StrictSubDataPropertyOf(pe, P).
  If pe is equivalent to owl:topDataProperty then the empty NodeSet will be returned.
- getEquivalentDataProperties
  
  public Node<OWLDataProperty> getEquivalentDataProperties(OWLDataProperty pe)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the set of named data properties that are equivalent to the specified data property expression with respect to the imports closure of the root ontology. The properties are returned as a Node.
  
  Specified by:
  
  getEquivalentDataProperties in interface OWLReasoner
  
  Parameters:
  
  pe - The data property expression whose equivalent properties are to be retrieved.
  
  Returns:
  
  A node containing the named data properties such that for each named data property P in the node, the set of reasoner axioms entails EquivalentDataProperties(pe P).
  If pe is a named data property then pe will be contained in the node.
  If pe is unsatisfiable with respect to the set of reasoner axioms then the node representing and containing owl:bottomDataProperty, i.e. the bottom node, will be returned.
  If ce is equivalent to owl:topDataProperty with respect to the set of reasoner axioms then the node representing and containing owl:topDataProperty, i.e. the top node, will be returned
  .
- getDisjointDataProperties
  
  public NodeSet<OWLDataProperty> getDisjointDataProperties(OWLDataPropertyExpression pe)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the data properties that are disjoint with the specified data property expression pe. The data properties are returned as a NodeSet.
  
  Specified by:
  
  getDisjointDataProperties in interface OWLReasoner
  
  Parameters:
  
  pe - The data property expression whose disjoint data properties are to be retrieved.
  
  Returns:
  
  The return value is a NodeSet such that for each data property P in the NodeSet the set of reasoner axioms entails EquivalentDataProperties(P, DataPropertyComplementOf(pe)) or StrictSubDataPropertyOf(P, DataPropertyComplementOf(pe)) .
- getDataPropertyDomains
  
  public NodeSet<OWLClass> getDataPropertyDomains(OWLDataProperty pe, boolean direct)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the named classes that are the direct or indirect domains of this property with respect to the imports closure of the root ontology. The classes are returned as a NodeSet .
  
  Specified by:
  
  getDataPropertyDomains in interface OWLReasoner
  
  Parameters:
  
  pe - The property expression whose domains are to be retrieved.
  
  direct - Specifies if the direct domains should be retrieved ( true), or if all domains should be retrieved ( false).
  
  Returns:
  
  Let N = getEquivalentClasses(DataSomeValuesFrom(pe rdfs:Literal)) .
  If direct is true: then if N is not empty then the return value is N, else the return value is the result of getSuperClasses(DataSomeValuesFrom(pe rdfs:Literal), true) .
  If direct is false: then the result of getSuperClasses(DataSomeValuesFrom(pe rdfs:Literal), false) together with N if N is non-empty.
  (Note, rdfs:Literal is the top datatype).
- getTypes
  
  public NodeSet<OWLClass> getTypes(OWLNamedIndividual ind, boolean direct)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the named classes which are (potentially direct) types of the specified named individual. The classes are returned as a NodeSet.
  
  Specified by:
  
  getTypes in interface OWLReasoner
  
  Parameters:
  
  ind - The individual whose types are to be retrieved.
  
  direct - Specifies if the direct types should be retrieved ( true), or if all types should be retrieved ( false).
  
  Returns:
  
  If direct is true, a NodeSet containing named classes such that for each named class C in the node set, the set of reasoner axioms entails DirectClassAssertion(C, ind).
  If direct is false, a NodeSet containing named classes such that for each named class C in the node set, the set of reasoner axioms entails ClassAssertion(C, ind).
- getInstances
  
  public NodeSet<OWLNamedIndividual> getInstances(OWLClassExpression ce, boolean direct)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the individuals which are instances of the specified class expression. The individuals are returned a a NodeSet.
  
  Specified by:
  
  getInstances in interface OWLReasoner
  
  Parameters:
  
  ce - The class expression whose instances are to be retrieved.
  
  direct - Specifies if the direct instances should be retrieved ( true), or if all instances should be retrieved ( false).
  
  Returns:
  
  If direct is true, a NodeSet containing named individuals such that for each named individual j in the node set, the set of reasoner axioms entails DirectClassAssertion(ce, j).
  If direct is false, a NodeSet containing named individuals such that for each named individual j in the node set, the set of reasoner axioms entails ClassAssertion(ce, j).
  If ce is unsatisfiable with respect to the set of reasoner axioms then the empty NodeSet is returned.
  
  See Also:
  
  IndividualNodeSetPolicy
- getObjectPropertyValues
  
  public NodeSet<OWLNamedIndividual> getObjectPropertyValues(OWLNamedIndividual ind, OWLObjectPropertyExpression pe)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the object property values for the specified individual and object property expression. The individuals are returned as a NodeSet.
  
  Specified by:
  
  getObjectPropertyValues in interface OWLReasoner
  
  Parameters:
  
  ind - The individual that is the subject of the object property values
  
  pe - The object property expression whose values are to be retrieved for the specified individual
  
  Returns:
  
  A NodeSet containing named individuals such that for each individual j in the node set, the set of reasoner axioms entails ObjectPropertyAssertion(pe ind j).
  
  See Also:
  
  IndividualNodeSetPolicy
- getDataPropertyValues
  
  public Set<OWLLiteral> getDataPropertyValues(OWLNamedIndividual ind, OWLDataProperty pe)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the data property values for the specified individual and data property expression. The values are a set of literals. Note that the results are not guaranteed to be complete for this method. The reasoner may also return canonical literals or they may be in a form that bears a resemblance to the syntax of the literals in the root ontology imports closure.
  
  Specified by:
  
  getDataPropertyValues in interface OWLReasoner
  
  Parameters:
  
  ind - The individual that is the subject of the data property values
  
  pe - The data property expression whose values are to be retrieved for the specified individual
  
  Returns:
  
  A set of OWLLiterals containing literals such that for each literal l in the set, the set of reasoner axioms entails DataPropertyAssertion(pe ind l).
  
  See Also:
  
  IndividualNodeSetPolicy
- getSameIndividuals
  
  public Node<OWLNamedIndividual> getSameIndividuals(OWLNamedIndividual ind)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the individuals that are the same as the specified individual.
  
  Specified by:
  
  getSameIndividuals in interface OWLReasoner
  
  Parameters:
  
  ind - The individual whose same individuals are to be retrieved.
  
  Returns:
  
  A node containing individuals such that for each individual j in the node, the root ontology imports closure entails SameIndividual(j, ind). Note that the node will contain j.
- getDifferentIndividuals
  
  public NodeSet<OWLNamedIndividual> getDifferentIndividuals(OWLNamedIndividual ind)
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the individuals which are entailed to be different from the specified individual. The individuals are returned as a NodeSet.
  
  Specified by:
  
  getDifferentIndividuals in interface OWLReasoner
  
  Parameters:
  
  ind - The individual whose different individuals are to be returned.
  
  Returns:
  
  A NodeSet containing OWLNamedIndividual s such that for each individual i in the NodeSet the set of reasoner axioms entails DifferentIndividuals(ind, i).
- getTimeOut
  
  public long getTimeOut()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the time out (in milliseconds) for the most basic reasoning operations. That is the maximum time for a satisfiability test, subsumption test etc. The time out should be set at reasoner creation time. During satisfiability (subsumption) checking the reasoner will check to see if the time it has spent doing the single check is longer than the value returned by this method. If this is the case, the reasoner will throw a TimeOutException in the thread that is executing the reasoning process.
  Note that clients that want a higher level timeout, at the level of classification for example, should start their own timers and request that the reasoner interrupts the current process using the OWLReasoner.interrupt() method.
  
  Specified by:
  
  getTimeOut in interface OWLReasoner
  
  Returns:
  
  The time out in milliseconds for basic reasoner operation. By default this is the value of Long.MAX_VALUE.
- getFreshEntityPolicy
  
  public FreshEntityPolicy getFreshEntityPolicy()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the Fresh Entity Policy in use by this reasoner. The policy is set at reasoner creation time.
  
  Specified by:
  
  getFreshEntityPolicy in interface OWLReasoner
  
  Returns:
  
  The policy.
- getIndividualNodeSetPolicy
  
  public IndividualNodeSetPolicy getIndividualNodeSetPolicy()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Gets the IndividualNodeSetPolicy in use by this reasoner. The policy is set at reasoner creation time.
  
  Specified by:
  
  getIndividualNodeSetPolicy in interface OWLReasoner
  
  Returns:
  
  The policy.
- dispose
  
  public void dispose()
  
  Description copied from interface: org.semanticweb.owlapi.reasoner.OWLReasoner
  
  Disposes of this reasoner. This frees up any resources used by the reasoner and detaches the reasoner as an OWLOntologyChangeListener from the OWLOntologyManager that manages the ontologies contained within the reasoner.
  
  Specified by:
  
  dispose in interface OWLReasoner

Class Reasoner

Method Summary

Methods inherited from class java.lang.Object

Method Details