org.semanticweb.owlapi.reasoner.structural
Class StructuralReasoner

java.lang.Object
  org.semanticweb.owlapi.reasoner.impl.OWLReasonerBase
      org.semanticweb.owlapi.reasoner.structural.StructuralReasoner

All Implemented Interfaces:

OWLReasoner

public class StructuralReasoner
extends OWLReasonerBase

Author: Matthew Horridge
The University of Manchester
Information Management Group
Date: 04-Dec-2009

This is a simple structural reasoner that essentially answers with told information. It is incomplete.

Constructor Summary

StructuralReasoner(OWLOntology rootOntology, OWLReasonerConfiguration configuration, BufferingMode bufferingMode)

Method Summary

void	dumpClassHierarchy(boolean showBottomNode)
void	dumpDataPropertyHierarchy(boolean showBottomNode)
void	dumpObjectPropertyHierarchy(boolean showBottomNode)
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.
protected OWLDataFactory	getDataFactory()
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.
java.util.Set<OWLLiteral>	getDataPropertyValues(OWLNamedIndividual ind, OWLDataProperty pe) Gets the data property values for the specified individual and data property.
NodeSet<OWLNamedIndividual>	getDifferentIndividuals(OWLNamedIndividual ind) Gets the individuals which are entailed to be different from the specified individual.
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.
IndividualNodeSetPolicy	getIndividualNodeSetPolicy() Gets the IndividualNodeSetPolicy in use by this reasoner.
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.
java.util.Set<InferenceType>	getPrecomputableInferenceTypes() Returns the set of InferenceTypes that are precomputable by reasoner.
java.lang.String	getReasonerName() Gets the name of this reasoner.
Version	getReasonerVersion() Gets the version of 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.
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.
protected void	handleChanges(java.util.Set<OWLAxiom> addAxioms, java.util.Set<OWLAxiom> removeAxioms) Asks the reasoner implementation to handle axiom additions and removals from the imports closure of the root ontology.
void	interrupt() Asks the reasoner to interrupt what it is currently doing.
boolean	isConsistent() Determines if the set of reasoner axioms is consistent.
boolean	isEntailed(OWLAxiom axiom) A convenience method that determines if the specified axiom is entailed by the set of reasoner axioms.
boolean	isEntailed(java.util.Set<? extends OWLAxiom> axioms) Determines if the specified set of axioms is entailed by the reasoner axioms.
boolean	isEntailmentCheckingSupported(AxiomType<?> axiomType) Determines if entailment checking for the specified axiom type is supported.
boolean	isPrecomputed(InferenceType inferenceType) Determines if a specific set of inferences have been precomputed.
boolean	isSatisfiable(OWLClassExpression classExpression) A convenience method that determines if the specified class expression is satisfiable with respect to the reasoner axioms.
void	precomputeInferences(InferenceType... inferenceTypes) Asks the reasoner to precompute certain types of inferences.
void	prepareReasoner()

Methods inherited from class org.semanticweb.owlapi.reasoner.impl.OWLReasonerBase

dispose, flush, getBufferingMode, getOWLDataFactory, getPendingAxiomAdditions, getPendingAxiomRemovals, getPendingChanges, getReasonerAxioms, getReasonerConfiguration, getRootOntology, getTimeOut

Methods inherited from class java.lang.Object

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

Constructor Detail

StructuralReasoner

public StructuralReasoner(OWLOntology rootOntology,
                          OWLReasonerConfiguration configuration,
                          BufferingMode bufferingMode)

Method Detail

getReasonerName

public java.lang.String getReasonerName()

Gets the name of this reasoner.

Returns:

A string that represents the name of this reasoner.

getFreshEntityPolicy

public FreshEntityPolicy getFreshEntityPolicy()

Description copied from interface: 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

Overrides:

getFreshEntityPolicy in class OWLReasonerBase

Returns:

The policy.

getIndividualNodeSetPolicy

public IndividualNodeSetPolicy getIndividualNodeSetPolicy()

Gets the IndividualNodeSetPolicy in use by this reasoner. The policy is set at reasoner creation time.

Specified by:

getIndividualNodeSetPolicy in interface OWLReasoner

Overrides:

getIndividualNodeSetPolicy in class OWLReasonerBase

Returns:

The policy.

getReasonerVersion

public Version getReasonerVersion()

Gets the version of this reasoner.

Returns:

The version of this reasoner. Not null.

handleChanges

protected void handleChanges(java.util.Set<OWLAxiom> addAxioms,
                             java.util.Set<OWLAxiom> removeAxioms)

Description copied from class: OWLReasonerBase

Asks the reasoner implementation to handle axiom additions and removals from the imports closure of the root ontology. The changes will not include annotation axiom additions and removals.

Specified by:

handleChanges in class OWLReasonerBase

Parameters:

addAxioms - The axioms to be added to the reasoner.

removeAxioms - The axioms to be removed from the reasoner

interrupt

public void interrupt()

Description copied from interface: 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.

prepareReasoner

public void prepareReasoner()
                     throws ReasonerInterruptedException,
                            TimeOutException

Throws:

ReasonerInterruptedException

TimeOutException

precomputeInferences

public void precomputeInferences(InferenceType... inferenceTypes)
                          throws ReasonerInterruptedException,
                                 TimeOutException,
                                 InconsistentOntologyException

Description copied from interface: 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.

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.

Throws:

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

isPrecomputed

public boolean isPrecomputed(InferenceType inferenceType)

Description copied from interface: OWLReasoner

Determines if a specific set of inferences have been precomputed.

Parameters:

inferenceType - The type of inference to check for.

Returns:

true if the specified type of inferences have been precomputed, otherwise false.

getPrecomputableInferenceTypes

public java.util.Set<InferenceType> getPrecomputableInferenceTypes()

Description copied from interface: OWLReasoner

Returns the set of InferenceTypes that are precomputable by reasoner.

Returns:

A set of InferenceTypes that can be precomputed by this reasoner.

isConsistent

public boolean isConsistent()
                     throws ReasonerInterruptedException,
                            TimeOutException

Description copied from interface: 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.

Returns:

true if the imports closure of the root ontology is consistent, or false if the imports closure of the root ontology is inconsistent.

Throws:

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process).

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

isSatisfiable

public boolean isSatisfiable(OWLClassExpression classExpression)
                      throws ReasonerInterruptedException,
                             TimeOutException,
                             ClassExpressionNotInProfileException,
                             FreshEntitiesException,
                             InconsistentOntologyException

Description copied from interface: OWLReasoner

A convenience method that determines if the specified class expression is satisfiable with respect to the reasoner axioms.

Parameters:

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

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

ClassExpressionNotInProfileException - if classExpression is not within the profile that is supported by this reasoner.

FreshEntitiesException - if the signature of the classExpression is not contained within the signature of the set of reasoner axioms.

InconsistentOntologyException - if the set of reasoner axioms is inconsistent

getUnsatisfiableClasses

public Node<OWLClass> getUnsatisfiableClasses()
                                       throws ReasonerInterruptedException,
                                              TimeOutException

Description copied from interface: OWLReasoner

A convenience method that obtains the classes in the signature of the root ontology that are unsatisfiable.

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.

Throws:

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

isEntailed

public boolean isEntailed(OWLAxiom axiom)
                   throws ReasonerInterruptedException,
                          UnsupportedEntailmentTypeException,
                          TimeOutException,
                          AxiomNotInProfileException,
                          FreshEntitiesException,
                          InconsistentOntologyException

Description copied from interface: OWLReasoner

A convenience method that determines if the specified axiom is entailed by the set of reasoner axioms.

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:

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

UnsupportedEntailmentTypeException - if the reasoner cannot perform a check to see if the specified axiom is entailed

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

AxiomNotInProfileException - if axiom is not in the profile that is supported by this reasoner.

FreshEntitiesException - if the signature of the axiom is not contained within the signature of the imports closure of the root ontology.

InconsistentOntologyException - if the set of reasoner axioms is inconsistent

See Also:

OWLReasoner.isEntailmentCheckingSupported(org.semanticweb.owlapi.model.AxiomType)

isEntailed

public boolean isEntailed(java.util.Set<? extends OWLAxiom> axioms)
                   throws ReasonerInterruptedException,
                          UnsupportedEntailmentTypeException,
                          TimeOutException,
                          AxiomNotInProfileException,
                          FreshEntitiesException,
                          InconsistentOntologyException

Description copied from interface: OWLReasoner

Determines if the specified set of axioms is entailed by the reasoner axioms.

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:

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

UnsupportedEntailmentTypeException - if the reasoner cannot perform a check to see if the specified axiom is entailed

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

AxiomNotInProfileException - if axiom is not in the profile that is supported by this reasoner.

FreshEntitiesException - if the signature of the set of axioms is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

InconsistentOntologyException - if the set of reasoner axioms is inconsistent

See Also:

OWLReasoner.isEntailmentCheckingSupported(org.semanticweb.owlapi.model.AxiomType)

isEntailmentCheckingSupported

public boolean isEntailmentCheckingSupported(AxiomType<?> axiomType)

Description copied from interface: OWLReasoner

Determines if entailment checking for the specified axiom type is supported.

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

Gets the Node corresponding to the top node (containing owl:Thing) in the class hierarchy.

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

Gets the Node corresponding to the bottom node (containing owl:Nothing) in the class hierarchy.

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 InconsistentOntologyException,
                                       ClassExpressionNotInProfileException,
                                       FreshEntitiesException,
                                       ReasonerInterruptedException,
                                       TimeOutException

Description copied from interface: 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.

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:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

ClassExpressionNotInProfileException - if classExpression is not within the profile that is supported by this reasoner.

FreshEntitiesException - if the signature of the classExpression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getSuperClasses

public NodeSet<OWLClass> getSuperClasses(OWLClassExpression ce,
                                         boolean direct)
                                  throws InconsistentOntologyException,
                                         ClassExpressionNotInProfileException,
                                         FreshEntitiesException,
                                         ReasonerInterruptedException,
                                         TimeOutException

Description copied from interface: 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.

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:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

ClassExpressionNotInProfileException - if classExpression is not within the profile that is supported by this reasoner.

FreshEntitiesException - if the signature of the classExpression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getEquivalentClasses

public Node<OWLClass> getEquivalentClasses(OWLClassExpression ce)
                                    throws InconsistentOntologyException,
                                           ClassExpressionNotInProfileException,
                                           FreshEntitiesException,
                                           ReasonerInterruptedException,
                                           TimeOutException

Description copied from interface: 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.

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:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

ClassExpressionNotInProfileException - if classExpression is not within the profile that is supported by this reasoner.

FreshEntitiesException - if the signature of the classExpression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getDisjointClasses

public NodeSet<OWLClass> getDisjointClasses(OWLClassExpression ce)

Description copied from interface: OWLReasoner

Gets the classes that are disjoint with the specified class expression ce. The classes are returned as a NodeSet.

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

getTopObjectPropertyNode

public Node<OWLObjectPropertyExpression> getTopObjectPropertyNode()

Description copied from interface: OWLReasoner

Gets the Node corresponding to the top node (containing owl:topObjectProperty) in the object property hierarchy.

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

Gets the Node corresponding to the bottom node (containing owl:bottomObjectProperty) in the object property hierarchy.

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)
                                                            throws InconsistentOntologyException,
                                                                   FreshEntitiesException,
                                                                   ReasonerInterruptedException,
                                                                   TimeOutException

Description copied from interface: 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.

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.

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the object property expression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getSuperObjectProperties

public NodeSet<OWLObjectPropertyExpression> getSuperObjectProperties(OWLObjectPropertyExpression pe,
                                                                     boolean direct)
                                                              throws InconsistentOntologyException,
                                                                     FreshEntitiesException,
                                                                     ReasonerInterruptedException,
                                                                     TimeOutException

Description copied from interface: 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.

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.

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the object property expression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getEquivalentObjectProperties

public Node<OWLObjectPropertyExpression> getEquivalentObjectProperties(OWLObjectPropertyExpression pe)
                                                                throws InconsistentOntologyException,
                                                                       FreshEntitiesException,
                                                                       ReasonerInterruptedException,
                                                                       TimeOutException

Description copied from interface: 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.

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

.

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the object property expression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getDisjointObjectProperties

public NodeSet<OWLObjectPropertyExpression> getDisjointObjectProperties(OWLObjectPropertyExpression pe)
                                                                 throws InconsistentOntologyException,
                                                                        FreshEntitiesException,
                                                                        ReasonerInterruptedException,
                                                                        TimeOutException

Description copied from interface: 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.

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

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of pe is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getInverseObjectProperties

public Node<OWLObjectPropertyExpression> getInverseObjectProperties(OWLObjectPropertyExpression pe)
                                                             throws InconsistentOntologyException,
                                                                    FreshEntitiesException,
                                                                    ReasonerInterruptedException,
                                                                    TimeOutException

Description copied from interface: 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

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

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the object property expression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getObjectPropertyDomains

public NodeSet<OWLClass> getObjectPropertyDomains(OWLObjectPropertyExpression pe,
                                                  boolean direct)
                                           throws InconsistentOntologyException,
                                                  FreshEntitiesException,
                                                  ReasonerInterruptedException,
                                                  TimeOutException

Description copied from interface: 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.

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.

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the object property expression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getObjectPropertyRanges

public NodeSet<OWLClass> getObjectPropertyRanges(OWLObjectPropertyExpression pe,
                                                 boolean direct)
                                          throws InconsistentOntologyException,
                                                 FreshEntitiesException,
                                                 ReasonerInterruptedException,
                                                 TimeOutException

Description copied from interface: 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.

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.

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the object property expression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getTopDataPropertyNode

public Node<OWLDataProperty> getTopDataPropertyNode()

Description copied from interface: OWLReasoner

Gets the Node corresponding to the top node (containing owl:topDataProperty) in the data property hierarchy.

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

Gets the Node corresponding to the bottom node (containing owl:bottomDataProperty) in the data property hierarchy.

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)
                                              throws InconsistentOntologyException,
                                                     FreshEntitiesException,
                                                     ReasonerInterruptedException,
                                                     TimeOutException

Description copied from interface: 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.

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.

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the data property is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getSuperDataProperties

public NodeSet<OWLDataProperty> getSuperDataProperties(OWLDataProperty pe,
                                                       boolean direct)
                                                throws InconsistentOntologyException,
                                                       FreshEntitiesException,
                                                       ReasonerInterruptedException,
                                                       TimeOutException

Description copied from interface: 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.

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.

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the data property is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getEquivalentDataProperties

public Node<OWLDataProperty> getEquivalentDataProperties(OWLDataProperty pe)
                                                  throws InconsistentOntologyException,
                                                         FreshEntitiesException,
                                                         ReasonerInterruptedException,
                                                         TimeOutException

Description copied from interface: 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.

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

.

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the data property expression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getDisjointDataProperties

public NodeSet<OWLDataProperty> getDisjointDataProperties(OWLDataPropertyExpression pe)
                                                   throws InconsistentOntologyException,
                                                          FreshEntitiesException,
                                                          ReasonerInterruptedException,
                                                          TimeOutException

Description copied from interface: OWLReasoner

Gets the data properties that are disjoint with the specified data property expression pe. The data properties are returned as a NodeSet.

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

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of pe is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getDataPropertyDomains

public NodeSet<OWLClass> getDataPropertyDomains(OWLDataProperty pe,
                                                boolean direct)
                                         throws InconsistentOntologyException,
                                                FreshEntitiesException,
                                                ReasonerInterruptedException,
                                                TimeOutException

Description copied from interface: 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.

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

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the object property expression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getTypes

public NodeSet<OWLClass> getTypes(OWLNamedIndividual ind,
                                  boolean direct)
                           throws InconsistentOntologyException,
                                  FreshEntitiesException,
                                  ReasonerInterruptedException,
                                  TimeOutException

Description copied from interface: OWLReasoner

Gets the named classes which are (potentially direct) types of the specified named individual. The classes are returned as a NodeSet.

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

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the individual is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getInstances

public NodeSet<OWLNamedIndividual> getInstances(OWLClassExpression ce,
                                                boolean direct)
                                         throws InconsistentOntologyException,
                                                ClassExpressionNotInProfileException,
                                                FreshEntitiesException,
                                                ReasonerInterruptedException,
                                                TimeOutException

Description copied from interface: OWLReasoner

Gets the individuals which are instances of the specified class expression. The individuals are returned a a NodeSet.

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.

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

ClassExpressionNotInProfileException - if the class expression ce is not in the profile that is supported by this reasoner.

FreshEntitiesException - if the signature of the class expression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

See Also:

org.semanticweb.owlapi.reasoner.IndividualNodeSetPolicy}

getObjectPropertyValues

public NodeSet<OWLNamedIndividual> getObjectPropertyValues(OWLNamedIndividual ind,
                                                           OWLObjectPropertyExpression pe)
                                                    throws InconsistentOntologyException,
                                                           FreshEntitiesException,
                                                           ReasonerInterruptedException,
                                                           TimeOutException

Description copied from interface: OWLReasoner

Gets the object property values for the specified individual and object property expression. The individuals are returned as a NodeSet.

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

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the individual and property expression is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

See Also:

org.semanticweb.owlapi.reasoner.IndividualNodeSetPolicy}

getDataPropertyValues

public java.util.Set<OWLLiteral> getDataPropertyValues(OWLNamedIndividual ind,
                                                       OWLDataProperty pe)
                                                throws InconsistentOntologyException,
                                                       FreshEntitiesException,
                                                       ReasonerInterruptedException,
                                                       TimeOutException

Gets the data property values for the specified individual and data property.

Parameters:

ind - The individual that is the subject of the data property values

pe - The data property 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, either there is an explicit data property assertion in the set of reasoner axioms DataPropertyAssertion(pe, ind, l), or, there is an explicit data property assertion in the set of reasoner axioms DataPropertyAssertion(S, ind, l) and the set of reasoner axioms entails SubDataPropertyOf(S, pe).

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the individual and property is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasonerBase.getTimeOut().

See Also:

org.semanticweb.owlapi.reasoner.IndividualNodeSetPolicy}

getSameIndividuals

public Node<OWLNamedIndividual> getSameIndividuals(OWLNamedIndividual ind)
                                            throws InconsistentOntologyException,
                                                   FreshEntitiesException,
                                                   ReasonerInterruptedException,
                                                   TimeOutException

Description copied from interface: OWLReasoner

Gets the individuals that are the same as the specified individual.

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.

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the individual is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getDifferentIndividuals

public NodeSet<OWLNamedIndividual> getDifferentIndividuals(OWLNamedIndividual ind)
                                                    throws InconsistentOntologyException,
                                                           FreshEntitiesException,
                                                           ReasonerInterruptedException,
                                                           TimeOutException

Description copied from interface: OWLReasoner

Gets the individuals which are entailed to be different from the specified individual. The individuals are returned as a NodeSet.

Parameters:

ind - The individual whose different individuals are to be returned.

Returns:

A NodeSet containing OWLNamedIndividuals such that for each individual i in the NodeSet the set of reasoner axioms entails DifferentIndividuals(ind, i).

Throws:

InconsistentOntologyException - if the imports closure of the root ontology is inconsistent

FreshEntitiesException - if the signature of the individual is not contained within the signature of the imports closure of the root ontology and the undeclared entity policy of this reasoner is set to FreshEntityPolicy.DISALLOW.

ReasonerInterruptedException - if the reasoning process was interrupted for any particular reason (for example if reasoning was cancelled by a client process)

TimeOutException - if the reasoner timed out during a basic reasoning operation. See OWLReasoner.getTimeOut().

getDataFactory

protected OWLDataFactory getDataFactory()

dumpClassHierarchy

public void dumpClassHierarchy(boolean showBottomNode)

dumpObjectPropertyHierarchy

public void dumpObjectPropertyHierarchy(boolean showBottomNode)

dumpDataPropertyHierarchy

public void dumpDataPropertyHierarchy(boolean showBottomNode)