}

        Role role=H(propertyExpression);

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

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

        Tableau tableau=getTableau();

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

        nodesToTest.addAll(m_objectRoleHierarchy.getTopNode().getChildNodes());

        while (!nodesToTest.isEmpty()) {

            HierarchyNode<Role> nodeToTest=nodesToTest.iterator().next();

            nodesToTest.remove(nodeToTest);

            Role roleToTest=nodeToTest.getRepresentative();

            Set<Atom> perTestAtoms=new HashSet<Atom>(2);

            perTestAtoms.add(roleAssertion);

            perTestAtoms.add(roleToTestAssertion);

            if (!tableau.isSatisfiable(false,perTestAtoms,null,null,null,null,new ReasoningTaskDescription(true,"disjointness of {0} and {1}",role,roleToTest))) {

                // disjoint

        Role role1=H(propertyExpression1);

        Role role2=H(propertyExpression2);

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

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

        Set<Atom> perTestAtoms=new HashSet<Atom>(2);

        perTestAtoms.add(roleAssertion1);

        perTestAtoms.add(roleAssertion2);

        Tableau tableau=getTableau();

        boolean disjoint=!tableau.isSatisfiable(false,perTestAtoms,null,null,null,null,new ReasoningTaskDescription(true,"disjointness of {0} and {1}",role1,role2));

            }

            AtomicRole atomicRole=H(propertyExpression.asOWLDataProperty());

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

            Constant freshConstant=Constant.createAnonymous("fresh-constant");

            Tableau tableau=getTableau();

            Set<HierarchyNode<AtomicRole>> nodesToTest=new HashSet<HierarchyNode<AtomicRole>>();

            nodesToTest.addAll(m_dataRoleHierarchy.getTopNode().getChildNodes());

            while (!nodesToTest.isEmpty()) {

                HierarchyNode<AtomicRole> nodeToTest=nodesToTest.iterator().next();

                nodesToTest.remove(nodeToTest);

                AtomicRole atomicRoleToTest=nodeToTest.getRepresentative();

                Set<Atom> perTestAtoms=new HashSet<Atom>(2);

                perTestAtoms.add(atomicRoleAssertion);

                perTestAtoms.add(atomicRoleToTestAssertion);

                if (!tableau.isSatisfiable(false,perTestAtoms,null,null,null,null,new ReasoningTaskDescription(true,"disjointness of {0} and {1}",atomicRole,atomicRoleToTest))) {

                    // disjoint

        public void visit(OWLObjectComplementOf object) {

            OWLClassExpression description=object.getOperand();

            if (description instanceof OWLObjectHasSelf) {

                OWLObjectPropertyExpression objectProperty=((OWLObjectHasSelf)description).getProperty();

                m_bodyAtoms.add(roleAtom);

            }

            /**

             * gstoil modification. This situation is now possible with automata. Since the translation says that for each final state f add inclusion f -> C. If C is a nominal and comes from a concept with negative polarity then subsumption is actually f-> \neg {o} which was not a valid HermiT normal form.

             */

 

            throw new IllegalStateException("Internal error: invalid normal form.");

        }

        public void visit(OWLObjectHasSelf object) {

            OWLObjectPropertyExpression objectProperty=object.getProperty();

            m_headAtoms.add(roleAtom);

        }

            for (int i=0;i<yVars.length;i++) {

                yVars[i]=nextY();

                m_bodyAtoms.add(getRoleAtom(onObjectProperty,X,yVars[i]));

                if (atomicConcept!=null) {

                    if (isPositive)

                        m_bodyAtoms.add(atom);

                    else

                        m_headAtoms.add(atom);

                }

    }

    protected boolean isEveryChildANonSubsumer(Set<HierarchyNode<AtomicConcept>> unknownSubsumerNodes,AtomicConcept pickedElement,int childNumberThreshold) {

        if (unknownSubsumerNodes.size()>childNumberThreshold) {

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

            Set<Atom> superconceptAssertions=new HashSet<Atom>();

            for (HierarchyNode<AtomicConcept> unknownSupNode : unknownSubsumerNodes)

                superconceptAssertions.add(Atom.create(unknownSupNode.getRepresentative(),freshIndividual));

            Object[] superconcepts=new Object[superconceptAssertions.size()];

            int index=0;