This file is part of HermiT.

   HermiT is free software: you can redistribute it and/or modify

   it under the terms of the GNU Lesser General Public License as published by

   the Free Software Foundation, either version 3 of the License, or

   (at your option) any later version.

   HermiT is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License

   along with HermiT.  If not, see <http://www.gnu.org/licenses/>.

*/

* Answers queries about the logical implications of a particular knowledge base. A Reasoner is associated with a single knowledge base, which is "loaded" when the reasoner is constructed. By default a full classification of all atomic terms in the knowledge base is also performed at this time (which can take quite a while for large or complex ontologies), but this behavior can be disabled as a part of the Reasoner configuration. Internal details of the loading and reasoning algorithms can be configured in the Reasoner constructor and do not change over the lifetime of the Reasoner object---internal data structures and caches are optimized for a particular configuration. By default, HermiT will use the set of options which provide optimal performance.

*/

    protected final OntologyChangeListener m_ontologyChangeListener;

    protected final Configuration m_configuration;

    protected final OWLOntology m_rootOntology;

    protected final List<OWLOntologyChange> m_pendingChanges;

    protected final Collection<DescriptionGraph> m_descriptionGraphs;

    protected final InterruptFlag m_interruptFlag;

    protected ObjectPropertyInclusionManager m_objectPropertyInclusionManager;

    protected DLOntology m_dlOntology;

    protected Prefixes m_prefixes;

    protected Tableau m_tableau;

    protected Boolean m_isConsistent;

    protected Hierarchy<AtomicConcept> m_atomicConceptHierarchy;

    protected Hierarchy<Role> m_objectRoleHierarchy;

    protected Hierarchy<AtomicRole> m_dataRoleHierarchy;

    protected Map<AtomicConcept,Set<Individual>> m_realization;

    protected Map<Role,Set<HierarchyNode<AtomicConcept>>> m_directObjectRoleDomains;

    protected Map<Role,Set<HierarchyNode<AtomicConcept>>> m_directObjectRoleRanges;

    protected Map<AtomicRole,Set<HierarchyNode<AtomicConcept>>> m_directDataRoleDomains;

    protected Map<AtomicRole,Map<Individual,Set<Individual>>> m_knownObjectPropertyRelations;

    protected Map<AtomicRole,Map<Individual,Set<Individual>>> m_possibleObjectPropertyRelations;

    /**

     * Creates a new reasoner object with standard parameters for blocking, expansion strategy etc. Then the given manager is used to find all required imports for the given ontology and the ontology with the imports is loaded into the reasoner and the data factory of the manager is used to create fresh concepts during the preprocessing phase if necessary.

     *

     * @param rootOntology

     *            - the ontology that should be loaded by the reasoner

     */

    public Reasoner(OWLOntology rootOntology) {

        this(new Configuration(),rootOntology,(Set<DescriptionGraph>)null);

    }

    /**

     * Creates a new reasoner object with the parameters for blocking, expansion strategy etc as specified in the given configuration object. A default configuration can be obtained by just passing new Configuration(). Then the given manager is used to find all required imports for the given ontology and the ontology with the imports is loaded into the reasoner and the data factory of the manager is used to create fresh concepts during the preprocessing phase if necessary.

     *

     * @param configuration

     *            - a configuration in which parameters can be defined such as the blocking strategy to be used etc

     * @param rootOntology

     *            - the ontology that should be loaded by the reasoner

     */

    public Reasoner(Configuration configuration,OWLOntology rootOntology) {

        this(configuration,rootOntology,(Set<DescriptionGraph>)null);

    }

    /**

     * Creates a new reasoner object loaded with the given ontology and the given description graphs. When creating the reasoner, the given configuration determines the parameters for blocking, expansion strategy etc. A default configuration can be obtained by just passing new Configuration(). Then the given manager is used to find all required imports for the given ontology and the ontology with the imports and the description graphs are loaded into the reasoner. The data factory of the manager is used to create fresh concepts during the preprocessing phase if necessary.

     *

     * @param configuration

     *            - a configuration in which parameters can be defined such as the blocking strategy to be used etc

     * @param rootOntology

     *            - the ontology that should be loaded by the reasoner

     * @param descriptionGraphs

     *            - a set of description graphs

     */

    public Reasoner(Configuration configuration,OWLOntology rootOntology,Collection<DescriptionGraph> descriptionGraphs) {

        m_ontologyChangeListener=new OntologyChangeListener();

        m_configuration=configuration;

        m_rootOntology=rootOntology;

        m_pendingChanges=new ArrayList<OWLOntologyChange>();

        m_rootOntology.getOWLOntologyManager().addOntologyChangeListener(m_ontologyChangeListener);

        if (descriptionGraphs==null)

            m_descriptionGraphs=Collections.emptySet();

        else

            m_descriptionGraphs=descriptionGraphs;

        m_interruptFlag=new InterruptFlag(configuration.individualTaskTimeout);

        loadOntology();

    }

    // Life-cycle management methods

    protected void loadOntology() {

        clearState();

        // Convert OWLOntology into DLOntology

        OWLClausification clausifier=new OWLClausification(m_configuration);

        Object[] result=clausifier.preprocessAndClausify(m_rootOntology,m_descriptionGraphs);

        m_objectPropertyInclusionManager=(ObjectPropertyInclusionManager)result[0];

        m_dlOntology=(DLOntology)result[1];

        // Load the DLOntology

        m_prefixes=createPrefixes(m_dlOntology);

        m_tableau=createTableau(m_interruptFlag,m_configuration,m_dlOntology,null,m_prefixes);

    }

    protected void finalize() {

        dispose();

    }

    public void dispose() {

        m_rootOntology.getOWLOntologyManager().removeOntologyChangeListener(m_ontologyChangeListener);

        clearState();

        m_interruptFlag.dispose();

    }

    protected void clearState() {

        m_pendingChanges.clear();

        m_dlOntology=null;

        m_prefixes=null;

        m_tableau=null;

        m_isConsistent=null;

        m_atomicConceptHierarchy=null;

        m_objectRoleHierarchy=null;

        m_dataRoleHierarchy=null;

        m_realization=null;

        m_directObjectRoleDomains=new HashMap<Role,Set<HierarchyNode<AtomicConcept>>>();

        m_directObjectRoleRanges=new HashMap<Role,Set<HierarchyNode<AtomicConcept>>>();

        m_directDataRoleDomains=new HashMap<AtomicRole,Set<HierarchyNode<AtomicConcept>>>();

        m_knownObjectPropertyRelations=null;

        m_possibleObjectPropertyRelations=null;

    }

    public void interrupt() {

        m_interruptFlag.interrupt();

    }

    public OWLDataFactory getDataFactory() {

        return m_rootOntology.getOWLOntologyManager().getOWLDataFactory();

    }

    // Accessor methods of the OWL API

    public String getReasonerName() {

        return getClass().getPackage().getImplementationTitle();

    }

    public Version getReasonerVersion() {

        String versionString=Reasoner.class.getPackage().getImplementationVersion();

        String[] splitted;

        int filled=0;

        int version[]=new int[4];

        if (versionString!=null) {

            splitted=versionString.split("\\.");

            while (filled<splitted.length) {

                version[filled]=Integer.parseInt(splitted[filled]);

                filled++;

            }

        }

        while (filled<version.length) {

            version[filled]=0;

            filled++;

        }

        return new Version(version[0],version[1],version[2],version[3]);

    }

    public OWLOntology getRootOntology() {

        return m_rootOntology;

    }

    public long getTimeOut() {

        return m_configuration.individualTaskTimeout;

    }

    public IndividualNodeSetPolicy getIndividualNodeSetPolicy() {

        return m_configuration.getIndividualNodeSetPolicy();

    }

    public FreshEntityPolicy getFreshEntityPolicy() {

        return m_configuration.getFreshEntityPolicy();

    }

    // HermiT's accessor methods

    public Prefixes getPrefixes() {

        return m_prefixes;

    }

    public DLOntology getDLOntology() {

        return m_dlOntology;

    }

    public Configuration getConfiguration() {

        return m_configuration.clone();

    }

    // Ontology change management methods

    public BufferingMode getBufferingMode() {

        return m_configuration.bufferChanges ? BufferingMode.BUFFERING : BufferingMode.NON_BUFFERING;

    }

    protected class OntologyChangeListener implements OWLOntologyChangeListener {

        public void ontologiesChanged(List<? extends OWLOntologyChange> changes) throws OWLException {

            for (OWLOntologyChange change : changes)

                if (!(change instanceof RemoveOntologyAnnotation || change instanceof AddOntologyAnnotation))

                    m_pendingChanges.add(change);

        }

    }

    public Set<OWLAxiom> getPendingAxiomAdditions() {

        Set<OWLAxiom> added=new HashSet<OWLAxiom>();

        for (OWLOntologyChange change : m_pendingChanges)

            if (change instanceof AddAxiom)

                added.add(change.getAxiom());

        return added;

    }

    public Set<OWLAxiom> getPendingAxiomRemovals() {

        Set<OWLAxiom> removed=new HashSet<OWLAxiom>();

        for (OWLOntologyChange change : m_pendingChanges)

            if (change instanceof RemoveAxiom)

                removed.add(change.getAxiom());

        return removed;

    }

    public List<OWLOntologyChange> getPendingChanges() {

        return m_pendingChanges;

    }

    public void flush() {

        if (!m_pendingChanges.isEmpty()) {

            loadOntology();

            m_pendingChanges.clear();

        }

    }

    // General inferences

    public boolean isDefined(OWLClass owlClass) {

        AtomicConcept atomicConcept=AtomicConcept.create(owlClass.getIRI().toString());

        return m_dlOntology.containsAtomicConcept(atomicConcept) || AtomicConcept.THING.equals(atomicConcept) || AtomicConcept.NOTHING.equals(atomicConcept);

    }

    public boolean isDefined(OWLIndividual owlIndividual) {

        Individual individual;

        if (owlIndividual.isAnonymous())

            individual=Individual.createAnonymous(owlIndividual.asOWLAnonymousIndividual().getID().toString());

        else

            individual=Individual.create(owlIndividual.asOWLNamedIndividual().getIRI().toString());

        return m_dlOntology.containsIndividual(individual);

    }

    public boolean isDefined(OWLObjectProperty owlObjectProperty) {

        AtomicRole atomicRole=AtomicRole.create(owlObjectProperty.getIRI().toString());

        return m_dlOntology.containsObjectRole(atomicRole) || AtomicRole.TOP_OBJECT_ROLE.equals(owlObjectProperty) || AtomicRole.BOTTOM_OBJECT_ROLE.equals(owlObjectProperty);

    }

    public boolean isDefined(OWLDataProperty owlDataProperty) {

        AtomicRole atomicRole=AtomicRole.create(owlDataProperty.getIRI().toString());

        return m_dlOntology.containsDataRole(atomicRole) || AtomicRole.TOP_DATA_ROLE.equals(atomicRole) || AtomicRole.BOTTOM_DATA_ROLE.equals(atomicRole);

    }

    public void prepareReasoner() {

        checkPreConditions();

        boolean doAll=m_configuration.prepareReasonerInferences==null;

        if (doAll || m_configuration.prepareReasonerInferences.classClassificationRequired)

            classify();

        if (doAll || m_configuration.prepareReasonerInferences.objectPropertyClassificationRequired)

            classifyObjectProperties();

        if (doAll || m_configuration.prepareReasonerInferences.dataPropertyClassificationRequired)

            classifyDataProperties();

        if (doAll || m_configuration.prepareReasonerInferences.objectPropertyRealisationRequired)

            realise();

    }

    public boolean isConsistent() {

        flushChangesIfRequired();

        if (m_isConsistent==null) {

            m_isConsistent=getTableau().isSatisfiable(true,true,null,null,null,null,null,ReasoningTaskDescription.isABoxSatisfiable());

        }

        return m_isConsistent;

    }

    public boolean isEntailmentCheckingSupported(AxiomType<?> axiomType) {

        return true;

    }

    public boolean isEntailed(OWLAxiom axiom) {

        checkPreConditions(axiom);

        if (!isConsistent())

            return true;

        EntailmentChecker checker=new EntailmentChecker(this,getDataFactory());

        return checker.entails(axiom);

    }

    public boolean isEntailed(Set<? extends OWLAxiom> axioms) {

        checkPreConditions(axioms.toArray(new OWLObject[0]));

        if (!m_isConsistent) return true;

        EntailmentChecker checker=new EntailmentChecker(this,getDataFactory());

        return checker.entails(axioms);

    }

    // Concept inferences

    public boolean isClassified() {

        return m_atomicConceptHierarchy!=null;

    }

    public void classify() {

        checkPreConditions();

        if (m_atomicConceptHierarchy==null) {

            Set<AtomicConcept> relevantAtomicConcepts=new HashSet<AtomicConcept>();

            relevantAtomicConcepts.add(AtomicConcept.THING);

            relevantAtomicConcepts.add(AtomicConcept.NOTHING);

            for (AtomicConcept atomicConcept : m_dlOntology.getAllAtomicConcepts())

                if (!Prefixes.isInternalIRI(atomicConcept.getIRI()))

                    relevantAtomicConcepts.add(atomicConcept);

            if (!m_isConsistent)

                m_atomicConceptHierarchy=Hierarchy.emptyHierarchy(relevantAtomicConcepts,AtomicConcept.THING,AtomicConcept.NOTHING);

            else {

                try {

                    final int numRelevantConcepts=relevantAtomicConcepts.size();

                    if (m_configuration.reasonerProgressMonitor!=null)

                        m_configuration.reasonerProgressMonitor.reasonerTaskStarted("Building the class hierarchy...");

                    ClassificationProgressMonitor progressMonitor=new ClassificationProgressMonitor() {

                        protected int m_processedConcepts=0;

                        public void elementClassified(AtomicConcept element) {

                            m_processedConcepts++;

                            if (m_configuration.reasonerProgressMonitor!=null)

                                m_configuration.reasonerProgressMonitor.reasonerTaskProgressChanged(m_processedConcepts,numRelevantConcepts);

                        }

                    };

                    m_atomicConceptHierarchy=classifyAtomicConcepts(getTableau(),progressMonitor,AtomicConcept.THING,AtomicConcept.NOTHING,relevantAtomicConcepts,m_configuration.forceQuasiOrderClassification);

                }

                finally {

                    if (m_configuration.reasonerProgressMonitor!=null)

                        m_configuration.reasonerProgressMonitor.reasonerTaskStopped();

                }

            }

        }

    }

    public Node<OWLClass> getTopClassNode() {

        classify();

        return atomicConceptHierarchyNodeToNode(m_atomicConceptHierarchy.getTopNode());

    }

    public Node<OWLClass> getBottomClassNode() {

        classify();

        return atomicConceptHierarchyNodeToNode(m_atomicConceptHierarchy.getBottomNode());

    }

    public boolean isSatisfiable(OWLClassExpression classExpression) {

        checkPreConditions(classExpression);

        if (!isConsistent())

            return false;

        if (classExpression instanceof OWLClass && m_atomicConceptHierarchy!=null) {

            AtomicConcept concept=H((OWLClass)classExpression);

            HierarchyNode<AtomicConcept> node=m_atomicConceptHierarchy.getNodeForElement(concept);

            return node!=m_atomicConceptHierarchy.getBottomNode();

        }

        else {

            OWLDataFactory factory=getDataFactory();

            OWLIndividual freshIndividual=factory.getOWLAnonymousIndividual("fresh-individual");

            OWLClassAssertionAxiom assertClassExpression=factory.getOWLClassAssertionAxiom(classExpression,freshIndividual);

            Tableau tableau=getTableau(assertClassExpression);

            return tableau.isSatisfiable(true,null,null,null,null,null,ReasoningTaskDescription.isConceptSatisfiable(classExpression));

        }

    }

    public boolean isSubClassOf(OWLClassExpression subClassExpression,OWLClassExpression superClassExpression) {

        checkPreConditions(subClassExpression,superClassExpression);

        if (!isConsistent() || subClassExpression.isOWLNothing() || superClassExpression.isOWLThing())

            return true;

        if (subClassExpression instanceof OWLClass && superClassExpression instanceof OWLClass) {

            AtomicConcept subconcept=H((OWLClass)subClassExpression);

            AtomicConcept superconcept=H((OWLClass)superClassExpression);

            if (m_atomicConceptHierarchy!=null && !containsFreshEntities(subClassExpression,superClassExpression)) {

                HierarchyNode<AtomicConcept> subconceptNode=m_atomicConceptHierarchy.getNodeForElement(subconcept);

                return subconceptNode.isEquivalentElement(superconcept) || subconceptNode.isAncestorElement(superconcept);

            }

            else {

                Tableau tableau=getTableau();

                Individual freshIndividual=Individual.createAnonymous("fresh-individual");

                Atom subconceptAssertion=Atom.create(subconcept,freshIndividual);

                Atom superconceptAssertion=Atom.create(superconcept,freshIndividual);

                return !tableau.isSatisfiable(true,Collections.singleton(subconceptAssertion),Collections.singleton(superconceptAssertion),null,null,null,ReasoningTaskDescription.isConceptSubsumedBy(subconcept,superconcept));

            }

        }

        else {

            OWLDataFactory factory=getDataFactory();

            OWLIndividual freshIndividual=factory.getOWLAnonymousIndividual("fresh-individual");

            OWLClassAssertionAxiom assertSubClassExpression=factory.getOWLClassAssertionAxiom(subClassExpression,freshIndividual);

            OWLClassAssertionAxiom assertNotSuperClassExpression=factory.getOWLClassAssertionAxiom(superClassExpression.getObjectComplementOf(),freshIndividual);

            Tableau tableau=getTableau(assertSubClassExpression,assertNotSuperClassExpression);

            return !tableau.isSatisfiable(true,null,null,null,null,null,ReasoningTaskDescription.isConceptSubsumedBy(subClassExpression,superClassExpression));

        }

    }

    public boolean isEquivalentClass(OWLClassExpression classExpression1,OWLClassExpression classExpression2) {

        return isSubClassOf(classExpression1,classExpression2) && isSubClassOf(classExpression2,classExpression1);

    }

    public Node<OWLClass> getEquivalentClasses(OWLClassExpression classExpression) {

        HierarchyNode<AtomicConcept> node=getHierarchyNode(classExpression);

        return atomicConceptHierarchyNodeToNode(node);

    }

    public NodeSet<OWLClass> getSuperClasses(OWLClassExpression classExpression,boolean direct) {

        HierarchyNode<AtomicConcept> node=getHierarchyNode(classExpression);

        Set<HierarchyNode<AtomicConcept>> result;

        if (direct)

            result=node.getParentNodes();

        else {

            result=new HashSet<HierarchyNode<AtomicConcept>>(node.getAncestorNodes());

            result.remove(node);

        }

        return atomicConceptHierarchyNodesToNodeSet(result);

    }

    public NodeSet<OWLClass> getAncestorClasses(OWLClassExpression classExpression) {

        HierarchyNode<AtomicConcept> node=getHierarchyNode(classExpression);

        return atomicConceptHierarchyNodesToNodeSet(node.getAncestorNodes());

    }

    public NodeSet<OWLClass> getSubClasses(OWLClassExpression classExpression,boolean direct) {

        HierarchyNode<AtomicConcept> node=getHierarchyNode(classExpression);

        Set<HierarchyNode<AtomicConcept>> result;

        if (direct)

            result=node.getChildNodes();

        else {

            result=new HashSet<HierarchyNode<AtomicConcept>>(node.getDescendantNodes());

            result.remove(node);

        }

        return atomicConceptHierarchyNodesToNodeSet(result);

    }

    public NodeSet<OWLClass> getDescendantClasses(OWLClassExpression classExpression) {

        HierarchyNode<AtomicConcept> node=getHierarchyNode(classExpression);

        return atomicConceptHierarchyNodesToNodeSet(node.getDescendantNodes());

    }

    public Node<OWLClass> getUnsatisfiableClasses() {

        classify();

        HierarchyNode<AtomicConcept> node=m_atomicConceptHierarchy.getBottomNode();

        return atomicConceptHierarchyNodeToNode(node);

    }

    public NodeSet<OWLClass> getDisjointClasses(OWLClassExpression classExpression,boolean direct) {

        Node<OWLClass> equivalentToComplement=getEquivalentClasses(classExpression.getObjectComplementOf());

        if (direct && equivalentToComplement.getSize()>0)

            return new OWLClassNodeSet(equivalentToComplement);

        NodeSet<OWLClass> subsDisjoint=getSubClasses(classExpression.getObjectComplementOf(),direct);

        if (direct)

            return subsDisjoint;

        Set<Node<OWLClass>> result=new HashSet<Node<OWLClass>>();

        if (equivalentToComplement.getSize() > 0) result.add(equivalentToComplement);

        result.addAll(subsDisjoint.getNodes());

        return new OWLClassNodeSet(result);

    }

    protected HierarchyNode<AtomicConcept> getHierarchyNode(OWLClassExpression classExpression) {

        checkPreConditions(classExpression);

        classify();

        if (!isConsistent())

            return m_atomicConceptHierarchy.getBottomNode();

        else if (classExpression instanceof OWLClass) {

            AtomicConcept atomicConcept=H((OWLClass)classExpression);

            HierarchyNode<AtomicConcept> node=m_atomicConceptHierarchy.getNodeForElement(atomicConcept);

            if (node==null)

                node=new HierarchyNode<AtomicConcept>(atomicConcept,Collections.singleton(atomicConcept),Collections.singleton(m_atomicConceptHierarchy.getTopNode()),Collections.singleton(m_atomicConceptHierarchy.getBottomNode()));

            return node;

        }

        else {

            OWLDataFactory factory=getDataFactory();

            OWLClass queryConcept=factory.getOWLClass(IRI.create("internal:query-concept"));

            OWLAxiom classDefinitionAxiom=factory.getOWLEquivalentClassesAxiom(queryConcept,classExpression);

            final Tableau tableau=getTableau(classDefinitionAxiom);

            HierarchySearch.Relation<AtomicConcept> hierarchyRelation=new HierarchySearch.Relation<AtomicConcept>() {

                public boolean doesSubsume(AtomicConcept parent,AtomicConcept child) {

                    Individual freshIndividual=Individual.createAnonymous("fresh-individual");

                    return !tableau.isSatisfiable(true,Collections.singleton(Atom.create(child,freshIndividual)),null,null,Collections.singleton(Atom.create(parent,freshIndividual)),null,ReasoningTaskDescription.isConceptSubsumedBy(child,parent));

                }

            };

            return HierarchySearch.findPosition(hierarchyRelation,AtomicConcept.create("internal:query-concept"),m_atomicConceptHierarchy.getTopNode(),m_atomicConceptHierarchy.getBottomNode());

        }

    }

    // Object property inferences

    public boolean areObjectPropertiesClassified() {

        return m_objectRoleHierarchy!=null;

    }

    public void classifyObjectProperties() {

        checkPreConditions();

        if (m_objectRoleHierarchy==null) {

            Set<Role> relevantObjectRoles=new HashSet<Role>();

            relevantObjectRoles.add(AtomicRole.TOP_OBJECT_ROLE);

            relevantObjectRoles.add(AtomicRole.BOTTOM_OBJECT_ROLE);

            for (AtomicRole atomicRole : m_dlOntology.getAllAtomicObjectRoles()) {

                relevantObjectRoles.add(atomicRole);

                if (m_dlOntology.hasInverseRoles())

                    relevantObjectRoles.add(atomicRole.getInverse());

            }

            if (!m_isConsistent)

                m_objectRoleHierarchy=Hierarchy.emptyHierarchy(relevantObjectRoles,AtomicRole.TOP_OBJECT_ROLE,AtomicRole.BOTTOM_OBJECT_ROLE);

            else {

                Map<Role,AtomicConcept> conceptsForRoles=new HashMap<Role,AtomicConcept>();

                final Map<AtomicConcept,Role> rolesForConcepts=new HashMap<AtomicConcept,Role>();

                // Create the additional axioms for classification

                List<OWLAxiom> additionalAxioms=new ArrayList<OWLAxiom>();

                OWLDataFactory factory=getDataFactory();

                OWLClass freshConcept=factory.getOWLClass(IRI.create("internal:fresh-concept"));

                for (Role objectRole : relevantObjectRoles) {

                    AtomicConcept conceptForRole;

                    OWLObjectPropertyExpression objectPropertyExpression;

                    if (objectRole instanceof AtomicRole) {

                        conceptForRole=AtomicConcept.create("internal:prop#"+((AtomicRole)objectRole).getIRI());

                        objectPropertyExpression=factory.getOWLObjectProperty(IRI.create(((AtomicRole)objectRole).getIRI()));

                    }

                    else {

                        conceptForRole=AtomicConcept.create("internal:prop#inv#"+((InverseRole)objectRole).getInverseOf().getIRI());

                        objectPropertyExpression=factory.getOWLObjectInverseOf(factory.getOWLObjectProperty(IRI.create(((InverseRole)objectRole).getInverseOf().getIRI())));

                    }

                    OWLClass classForRole=factory.getOWLClass(IRI.create(conceptForRole.getIRI()));

                    OWLAxiom axiom=factory.getOWLEquivalentClassesAxiom(classForRole,factory.getOWLObjectSomeValuesFrom(objectPropertyExpression,freshConcept));

                    additionalAxioms.add(axiom);

                    conceptsForRoles.put(objectRole,conceptForRole);

                    rolesForConcepts.put(conceptForRole,objectRole);

                }

                OWLAxiom[] additionalAxiomsArray=new OWLAxiom[additionalAxioms.size()];

                additionalAxioms.toArray(additionalAxiomsArray);

                // Run the actual classification task

                Tableau tableau=getTableau(additionalAxiomsArray);

                try {

                    final int numberOfRoles=relevantObjectRoles.size();

                    if (m_configuration.reasonerProgressMonitor!=null)

                        m_configuration.reasonerProgressMonitor.reasonerTaskStarted("Classifying object properties...");

                    ClassificationProgressMonitor progressMonitor=new ClassificationProgressMonitor() {

                        protected int m_processedRoles=0;

                        public void elementClassified(AtomicConcept element) {

                            m_processedRoles++;

                            if (m_configuration.reasonerProgressMonitor!=null)

                                m_configuration.reasonerProgressMonitor.reasonerTaskProgressChanged(m_processedRoles,numberOfRoles);

                        }

                    };

                    Hierarchy<AtomicConcept> atomicConceptHierarchyForRoles=classifyAtomicConceptsForRoles(tableau,progressMonitor,conceptsForRoles.get(AtomicRole.TOP_OBJECT_ROLE),conceptsForRoles.get(AtomicRole.BOTTOM_OBJECT_ROLE),rolesForConcepts.keySet(),m_dlOntology.hasInverseRoles(),conceptsForRoles,rolesForConcepts,m_configuration.forceQuasiOrderClassification);

                    Hierarchy.Transformer<AtomicConcept,Role> transformer=new Hierarchy.Transformer<AtomicConcept,Role>() {

                        public Role transform(AtomicConcept atomicConcept) {

                            return rolesForConcepts.get(atomicConcept);

                        }

                        public Role determineRepresentative(AtomicConcept oldRepresentative,Set<Role> newEquivalentElements) {

                            return transform(oldRepresentative);

                        }

                    };

                    m_objectRoleHierarchy=atomicConceptHierarchyForRoles.transform(transformer,null);

                }

                finally {

                    if (m_configuration.reasonerProgressMonitor!=null)

                        m_configuration.reasonerProgressMonitor.reasonerTaskStopped();

                }

            }

        }

    }

    public Node<OWLObjectProperty> getTopObjectPropertyNode() {

        classifyObjectProperties();

        return objectPropertyHierarchyNodeToNode(m_objectRoleHierarchy.getTopNode());

    }

    public Node<OWLObjectProperty> getBottomObjectPropertyNode() {

        classifyObjectProperties();

        return objectPropertyHierarchyNodeToNode(m_objectRoleHierarchy.getBottomNode());

    }

    public boolean isSubObjectPropertyExpressionOf(OWLObjectPropertyExpression subObjectPropertyExpression,OWLObjectPropertyExpression superObjectPropertyExpression) {

        checkPreConditions(subObjectPropertyExpression,superObjectPropertyExpression);

        if (!m_isConsistent || subObjectPropertyExpression.getNamedProperty().isOWLBottomObjectProperty() || superObjectPropertyExpression.getNamedProperty().isOWLTopObjectProperty())

            return true;

        Role subrole=H(subObjectPropertyExpression);

        Role superrole=H(superObjectPropertyExpression);

        if (m_objectRoleHierarchy!=null && !containsFreshEntities(subObjectPropertyExpression,superObjectPropertyExpression)) {

            HierarchyNode<Role> subroleNode=m_objectRoleHierarchy.getNodeForElement(subrole);

            return subroleNode.isEquivalentElement(superrole) || subroleNode.isAncestorElement(superrole);

        }

        else {

            OWLDataFactory factory=getDataFactory();

            OWLClass pseudoNominal=factory.getOWLClass(IRI.create("internal:pseudo-nominal"));

            OWLClassExpression allSuperNotPseudoNominal=factory.getOWLObjectAllValuesFrom(superObjectPropertyExpression,pseudoNominal.getObjectComplementOf());

            OWLIndividual freshIndividualA=factory.getOWLAnonymousIndividual("fresh-individual-A");

            OWLIndividual freshIndividualB=factory.getOWLAnonymousIndividual("fresh-individual-B");

            OWLAxiom subObjectPropertyAssertion=factory.getOWLObjectPropertyAssertionAxiom(subObjectPropertyExpression,freshIndividualA,freshIndividualB);

            OWLAxiom pseudoNominalAssertion=factory.getOWLClassAssertionAxiom(pseudoNominal,freshIndividualB);

            OWLAxiom allSuperNotPseudoNominalAssertion=factory.getOWLClassAssertionAxiom(allSuperNotPseudoNominal,freshIndividualA);

            Tableau tableau=getTableau(subObjectPropertyAssertion,pseudoNominalAssertion,allSuperNotPseudoNominalAssertion);

            return !tableau.isSatisfiable(true,null,null,null,null,null,ReasoningTaskDescription.isRoleSubsumedBy(subrole,superrole,true));

        }

    }

    public boolean isSubObjectPropertyExpressionOf(List<OWLObjectPropertyExpression> subPropertyChain,OWLObjectPropertyExpression superObjectPropertyExpression) {

        OWLObject[] objects=new OWLObject[subPropertyChain.size()+1];

        for (int i=0;i<subPropertyChain.size();i++)

            objects[i]=subPropertyChain.get(i);

        objects[subPropertyChain.size()]=superObjectPropertyExpression;

        checkPreConditions(objects);

        if (!m_isConsistent || superObjectPropertyExpression.getNamedProperty().isOWLTopObjectProperty())

            return true;

        else {

            OWLDataFactory factory=getDataFactory();

            OWLClass pseudoNominal=factory.getOWLClass(IRI.create("internal:pseudo-nominal"));

            OWLClassExpression allSuperNotPseudoNominal=factory.getOWLObjectAllValuesFrom(superObjectPropertyExpression,pseudoNominal.getObjectComplementOf());

            OWLAxiom[] additionalAxioms=new OWLAxiom[subPropertyChain.size()+2];

            int axiomIndex=0;

            for (OWLObjectPropertyExpression subObjectPropertyExpression : subPropertyChain) {

                OWLIndividual first=factory.getOWLAnonymousIndividual("fresh-individual-"+axiomIndex);

                OWLIndividual second=factory.getOWLAnonymousIndividual("fresh-individual-"+(axiomIndex+1));

                additionalAxioms[axiomIndex++]=factory.getOWLObjectPropertyAssertionAxiom(subObjectPropertyExpression,first,second);

            }

            OWLIndividual freshIndividual0=factory.getOWLAnonymousIndividual("fresh-individual-0");

            OWLIndividual freshIndividualN=factory.getOWLAnonymousIndividual("fresh-individual-"+subPropertyChain.size());

            additionalAxioms[axiomIndex++]=factory.getOWLClassAssertionAxiom(pseudoNominal,freshIndividualN);

            additionalAxioms[axiomIndex++]=factory.getOWLClassAssertionAxiom(allSuperNotPseudoNominal,freshIndividual0);

            Tableau tableau=getTableau(additionalAxioms);

            return !tableau.isSatisfiable(true,null,null,null,null,null,new ReasoningTaskDescription(true,"subproperty chain subsumption"));

        }

    }

    public boolean isEquivalentObjectPropertyExpression(OWLObjectPropertyExpression objectPropertyExpression1,OWLObjectPropertyExpression objectPropertyExpression2) {

        return isSubObjectPropertyExpressionOf(objectPropertyExpression1,objectPropertyExpression2) && isSubObjectPropertyExpressionOf(objectPropertyExpression2,objectPropertyExpression1);

    }

    public NodeSet<OWLObjectProperty> getSuperObjectProperties(OWLObjectPropertyExpression propertyExpression,boolean direct) {

        HierarchyNode<Role> node=getHierarchyNode(propertyExpression);

        Set<HierarchyNode<Role>> result=new HashSet<HierarchyNode<Role>>();

        if (direct) {

            // if the node contains only inverses, we have to add the successor nodes instead

            for (HierarchyNode<Role> n : node.getParentNodes()) {

                result.addAll(findClosestAtomicRoleContainingAntecedants(n));

            }

        } else {

            result=node.getAncestorNodes();

            result.remove(node);

        }

        return objectPropertyHierarchyNodesToNodeSet(result);

    }

    protected Set<HierarchyNode<Role>> findClosestAtomicRoleContainingAntecedants(HierarchyNode<Role> node) {

        Set<HierarchyNode<Role>> result=new HashSet<HierarchyNode<Role>>();

        boolean hasAtomicRole=false;

        for (Role r : node.getEquivalentElements()) {

            if (r instanceof AtomicRole) {

                hasAtomicRole=true;

                break;

            }

        }

        if (hasAtomicRole) {

            result.add(node);

        } else {

            for (HierarchyNode<Role> parent : node.getParentNodes()) {

                result.addAll(findClosestAtomicRoleContainingAntecedants(parent));

            }

        }

        return result;

    }

    public NodeSet<OWLObjectProperty> getAncestorObjectProperties(OWLObjectPropertyExpression propertyExpression) {

        HierarchyNode<Role> node=getHierarchyNode(propertyExpression);

        return objectPropertyHierarchyNodesToNodeSet(node.getAncestorNodes());

    }

    public NodeSet<OWLObjectProperty> getSubObjectProperties(OWLObjectPropertyExpression propertyExpression,boolean direct) {

        HierarchyNode<Role> node=getHierarchyNode(propertyExpression);

        Set<HierarchyNode<Role>> result=new HashSet<HierarchyNode<Role>>();

        if (direct) {

            // if the node contains only inverses, we have to add the successor nodes instead

            for (HierarchyNode<Role> n : node.getChildNodes()) {

                result.addAll(findClosestAtomicRoleContainingDescendants(n));

            }

        } else {

            result=node.getDescendantNodes();

            result.remove(node);

        }

        return objectPropertyHierarchyNodesToNodeSet(result);

    }

    protected Set<HierarchyNode<Role>> findClosestAtomicRoleContainingDescendants(HierarchyNode<Role> node) {

        Set<HierarchyNode<Role>> result=new HashSet<HierarchyNode<Role>>();

        boolean hasAtomicRole=false;

        for (Role r : node.getEquivalentElements()) {

            if (r instanceof AtomicRole) {

                hasAtomicRole=true;

                break;

            }

        }

        if (hasAtomicRole) {

            result.add(node);

        } else {

            for (HierarchyNode<Role> child : node.getChildNodes()) {

                result.addAll(findClosestAtomicRoleContainingDescendants(child));

            }

        }

        return result;

    }

    public NodeSet<OWLObjectProperty> getDescendantObjectProperties(OWLObjectPropertyExpression propertyExpression) {

        HierarchyNode<Role> node=getHierarchyNode(propertyExpression);

        return objectPropertyHierarchyNodesToNodeSet(node.getDescendantNodes());

    }

    public Node<OWLObjectProperty> getEquivalentObjectProperties(OWLObjectPropertyExpression propertyExpression) {

        return objectPropertyHierarchyNodeToNode(getHierarchyNode(propertyExpression));

    }

    public NodeSet<OWLClass> getObjectPropertyDomains(OWLObjectPropertyExpression propertyExpression,boolean direct) {

        checkPreConditions(propertyExpression);

        classify();

        if (!isConsistent())

            return new OWLClassNodeSet(getBottomClassNode());

        final Role role=H(propertyExpression);

        Set<HierarchyNode<AtomicConcept>> nodes=m_directObjectRoleDomains.get(role);

        if (nodes==null) {

            final Individual freshIndividualA=Individual.createAnonymous("fresh-individual-A");

            final Individual freshIndividualB=Individual.createAnonymous("fresh-individual-B");

            final Set<Atom> roleAssertion=Collections.singleton(role.getRoleAssertion(freshIndividualA,freshIndividualB));

            final Tableau tableau=getTableau();

            HierarchySearch.SearchPredicate<HierarchyNode<AtomicConcept>> searchPredicate=new HierarchySearch.SearchPredicate<HierarchyNode<AtomicConcept>>() {

                public Set<HierarchyNode<AtomicConcept>> getSuccessorElements(HierarchyNode<AtomicConcept> u) {

                    return u.getChildNodes();

                }

                public Set<HierarchyNode<AtomicConcept>> getPredecessorElements(HierarchyNode<AtomicConcept> u) {

                    return u.getParentNodes();

                }

                public boolean trueOf(HierarchyNode<AtomicConcept> u) {

                    AtomicConcept potentialDomainConcept=u.getRepresentative();

                    return !tableau.isSatisfiable(false,roleAssertion,Collections.singleton(Atom.create(potentialDomainConcept,freshIndividualA)),null,null,null,ReasoningTaskDescription.isDomainOf(potentialDomainConcept,role));

                }

            };

            nodes=HierarchySearch.search(searchPredicate,Collections.singleton(m_atomicConceptHierarchy.getTopNode()),null);

            m_directObjectRoleDomains.put(role,nodes);

        }

        if (!direct)

            nodes=HierarchyNode.getAncestorNodes(nodes);

        return atomicConceptHierarchyNodesToNodeSet(nodes);