Repository: dice-group/owlapy (language: python)

Issue:
Iri.reminder RecursionError:
https://github.com/dice-group/owlapy/blob/a619e2c5dbfce8943bc66c509d58e6f8ab2175fc/owlapy/iri.py#L153


`i.iri.reminder` and `i.iri.reminder()` lead to RecursionError: maximum recursion depth exceeded


`i.iri.get_short_form()` works perfectly fine. We should stick with `i.iri.reminder`  for the sake of readability.

owlapy.__version__
'1.0.2'



Discussion / hints:

Fix patch:
diff --git a/docs/index.rst b/docs/index.rst
index 5afacc29..21fcae58 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -14,6 +14,5 @@ Welcome to OWLAPY!
    usage/usage_examples
    usage/ontologies
    usage/reasoner
-   usage/reasoning_details
    usage/owlapi_adaptor
    autoapi/owlapy/index
\ No newline at end of file
diff --git a/docs/usage/ontologies.md b/docs/usage/ontologies.md
index c2bd646f..098eaa2f 100644
--- a/docs/usage/ontologies.md
+++ b/docs/usage/ontologies.md
@@ -202,10 +202,10 @@ When an _OWLOntologyManager_ object is created, a new world is also created as a
 By calling the method `load_ontology(iri)` the ontology is loaded to this world. 
 
 It possible to create several isolated “worlds”, sometimes
-called “universe of speech”. This makes it possible in particular to load
+called “universe of speech”. This makes it possible, in particular, to load
 the same ontology several times, independently, that is to say, without
-the modifications made on one copy affecting the other copy. Sometimes the need to [isolate an ontology](reasoning_details.md#isolated-world) 
-arise. What that means is that you can have multiple reference of the same ontology in different
+the modifications made on one copy affecting the other copy. Sometimes the need to isolate 
+an ontology arise. What that means is that you can have multiple reference of the same ontology in different
 worlds.
 
 -------------------------------------------------------------------------------------
diff --git a/docs/usage/owlapi_adaptor.md b/docs/usage/owlapi_adaptor.md
index c7cda17e..3cfb288a 100644
--- a/docs/usage/owlapi_adaptor.md
+++ b/docs/usage/owlapi_adaptor.md
@@ -48,6 +48,10 @@ Isn't that awesome!
 `OWLAPIAdaptor` uses HermiT reasoner by default. You can choose between:
 "HermiT", "Pellet", "JFact" and "Openllet".
 
+You can use the reasoning method directly from the adaptor but 
+for classes that require an [OWLReasoner](owlapi.owl_reasoner.OWLReasoner)
+you can use [SyncReasoner](https://dice-group.github.io/owlapy/autoapi/owlapy/owl_reasoner/index.html#owlapy.owl_reasoner.SyncReasoner).
+
 _**owlapi version**: 5.1.9_
 
 ## Examples
diff --git a/docs/usage/reasoner.md b/docs/usage/reasoner.md
index 45432294..59bd898b 100644
--- a/docs/usage/reasoner.md
+++ b/docs/usage/reasoner.md
@@ -13,14 +13,16 @@ onto = manager.load_ontology(IRI.create("KGs/Family/father.owl"))
 ```
 
 In our Owlapy library, we provide several **reasoners** to choose
-from. Currently, there are the following reasoners available: 
+from:
 
 - [**OntologyReasoner**](owlapy.owl_reasoner.OntologyReasoner)
 
     Or differently Structural Reasoner, is the base reasoner in Owlapy. The functionalities
   of this reasoner are limited. It does not provide full reasoning in _ALCH_. Furthermore,
   it has no support for instances of complex class expressions, which is covered by the
-  other reasoners (SyncReasoner and FIC). We recommend to use the other reasoners for any heavy reasoning tasks.
+  other reasoners (SyncReasoner and FIC). This reasoner is used as
+  a base reasoner for FIC which overwrites the `instances` method. 
+  We recommend using the other reasoners for any reasoning tasks.
 
     **Initialization:**
 
@@ -31,30 +33,27 @@ from. Currently, there are the following reasoners available:
    ```
 
     The structural reasoner requires an ontology ([OWLOntology](owlapy.owl_ontology.OWLOntology)).
-  The second argument is `isolate` argument which isolates the world (therefore the ontology) where the reasoner is
-  performing the reasoning. More on that on _[Reasoning Details](reasoning_details.md#isolated-world)_.
     
 
 
 - [**SyncReasoner**](owlapy.owl_reasoner.SyncReasoner)
 
-    Can perform full reasoning in _ALCH_ due to the use of HermiT/Pellet and provides support for
-  complex class expression instances (when using the method `instances`). SyncReasoner is more useful when
-  your main goal is reasoning over the ontology.
+    Can perform full reasoning in _ALCH_ due to the use of reasoners from 
+  owlapi like HermiT, Pellet, etc. and provides support for
+  complex class expression instances (when using the method `instances`). 
+  SyncReasoner is more useful when your main goal is reasoning over the ontology,
+  and you are familiarized with the java reasoners (HermiT, Pellet, ...).
 
     **Initialization:**
 
     ```python
-    from owlapy.owl_reasoner import SyncReasoner, BaseReasoner
+    from owlapy.owl_reasoner import SyncReasoner
     
-    sync_reasoner = SyncReasoner(onto, BaseReasoner.HERMIT, infer_property_values = True)
+    sync_reasoner = SyncReasoner(ontology_path="KGs/Mutagenesis/mutagenesis.owl", reasoner="HermiT")
     ```
     
-    Sync Reasoner requires an ontology and a base reasoner of type [BaseReasoner](owlapy.owl_reasoner.BaseReasoner)
-    which is just an enumeration with two possible values: `BaseReasoner.HERMIT` and `BaseReasoner.PELLET`.
-  You can set the `infer_property_values` argument to `True` if you want the reasoner to infer
-  property values. `infer_data_property_values` is an additional argument when the base reasoner is set to 
-    `BaseReasoner.PELLET`. The argument `isolated` is inherited from the base class
+    Sync Reasoner is made available by [owlapi adaptor](owlapi_adaptor.md) and requires the ontology path
+    together with a reasoner name from the possible set of reasoners: `"Hermit"`, `"Pellet"`, `"JFact"`, `"Openllet"`.
 
 
 - [**FastInstanceCheckerReasoner**](owlapy.owl_reasoner.FastInstanceCheckerReasoner) **(FIC)**
@@ -74,7 +73,8 @@ from. Currently, there are the following reasoners available:
     ```
     Besides the ontology, FIC requires a base reasoner to delegate any reasoning tasks not covered by it.
   This base reasoner
-  can be any other reasoner in Owlapy. `property_cache` specifies whether to cache property values. This
+  can be any other reasoner in Owlapy (usually it's [OntologyReasoner](owlapy.owl_reasoner.OntologyReasoner)).
+  `property_cache` specifies whether to cache property values. This
   requires more memory, but it speeds up the reasoning processes. If `negation_default` argument is set
   to `True` the missing facts in the ontology means false. The argument
     `sub_properties` is another boolean argument to specify whether you want to take sub properties in consideration
@@ -83,15 +83,11 @@ from. Currently, there are the following reasoners available:
 ## Usage of the Reasoner
 All the reasoners available in the Owlapy library inherit from the
 class: [OWLReasonerEx](owlapy.owl_reasoner.OWLReasonerEx). This class provides some 
-extra convenient methods compared to its base class [OWLReasoner](owlapy.owl_reasoner.OWLReasoner), which is an 
-abstract class.
-Further on, in this guide, we use 
-[SyncReasoner](owlapy.owl_reasoner.SyncReasoner).
+extra convenient methods compared to its base abstract class [OWLReasoner](owlapy.owl_reasoner.OWLReasoner).
+Further on, in this guide, we use [FastInstanceCheckerReasoner](owlapy.owl_reasoner.FastInstanceCheckerReasoner)
 to show the capabilities of a reasoner in Owlapy.
 
-To give examples we consider the _father_ dataset. 
-If you are not already familiar with this small dataset,
-you can find an overview of it [here](ontologies.md).
+As mentioned earlier we will use the _father_ dataset to give examples.
 
 
 ## Class Reasoning
@@ -109,9 +105,9 @@ from owlapy.iri import IRI
 namespace = "http://example.com/father#"
 male = OWLClass(IRI(namespace, "male"))
 
-male_super_classes = sync_reasoner.super_classes(male)
-male_sub_classes = sync_reasoner.sub_classes(male)
-male_equivalent_classes = sync_reasoner.equivalent_classes(male)
+male_super_classes = fic_reasoner.super_classes(male)
+male_sub_classes = fic_reasoner.sub_classes(male)
+male_equivalent_classes = fic_reasoner.equivalent_classes(male)
 ```
 
 We define the _male_ class by creating an [OWLClass](owlapy.class_expression.owl_class.OWLClass) object. The 
@@ -127,6 +123,10 @@ means that it will return only the named classes.
 >**NOTE**: The extra arguments `direct` and `only_named` are also used in other methods that reason
 upon the class, object property, or data property hierarchy.
 
+>**NOTE**: SyncReasoner implements OWLReasoner where we can specify the `only_named` argument
+> in some methods but in java reasoners there is no use for such argument and therefore this
+> argument is trivial when used in SyncReasoner's methods. 
+
 You can get all the types of a certain individual using `types` method:
 
 <!--pytest-codeblocks:cont-->
@@ -134,7 +134,7 @@ You can get all the types of a certain individual using `types` method:
 ```python
 anna = list(onto.individuals_in_signature()).pop()
 
-anna_types = sync_reasoner.types(anna)
+anna_types = fic_reasoner.types(anna)
 ```
 
 We retrieve _anna_ as the first individual on the list of individuals 
@@ -144,7 +144,7 @@ of the 'Father' ontology. The `type` method only returns named classes.
 ## Object Properties and Data Properties Reasoning
 Owlapy reasoners offers some convenient methods for working with object properties and 
 data properties. Below we show some of them, but you can always check all the methods in the 
-[SyncReasoner](owlapy.owl_reasoner.SyncReasoner)
+[OWLReasoner](owlapy.owl_reasoner.OWLReasoner)
 class documentation. 
 
 You can get all the object properties that an individual has by using the 
@@ -153,7 +153,7 @@ following method:
 <!--pytest-codeblocks:cont-->
 ```python
 anna = individuals[0] 
-object_properties = sync_reasoner.ind_object_properties(anna)
+object_properties = fic_reasoner.ind_object_properties(anna)
 ```
 In this example, `object_properties` contains all the object properties
 that _anna_ has, which in our case would only be _hasChild_.
@@ -162,7 +162,7 @@ Now we can get the individuals of this object property for _anna_.
 <!--pytest-codeblocks:cont-->
 ```python
 for op in object_properties:
-    object_properties_values = sync_reasoner.object_property_values(anna, op)
+    object_properties_values = fic_reasoner.object_property_values(anna, op)
     for individual in object_properties_values:
         print(individual)
 ```
@@ -190,16 +190,16 @@ from owlapy.owl_property import OWLObjectProperty
 
 hasChild = OWLObjectProperty(IRI(namespace, "hasChild"))
 
-equivalent_to_hasChild = sync_reasoner.equivalent_object_properties(hasChild)
-hasChild_sub_properties = sync_reasoner.sub_object_properties(hasChild)
+equivalent_to_hasChild = fic_reasoner.equivalent_object_properties(hasChild)
+hasChild_sub_properties = fic_reasoner.sub_object_properties(hasChild)
 ```
 
 In case you want to get the domains and ranges of an object property use the following:
 
 <!--pytest-codeblocks:cont-->
 ```python
-hasChild_domains = sync_reasoner.object_property_domains(hasChild)
-hasChild_ranges = sync_reasoner.object_property_ranges(hasChild)
+hasChild_domains = fic_reasoner.object_property_domains(hasChild)
+hasChild_ranges = fic_reasoner.object_property_ranges(hasChild)
 ```
 
 > **NOTE:** Again, you can do the same for data properties but instead of the word 'object' in the 
@@ -217,15 +217,15 @@ Let us now show a simple example by finding the instances of the class _male_ an
 
 <!--pytest-codeblocks:cont-->
 ```python
-male_individuals = sync_reasoner.instances(male)
+male_individuals = fic_reasoner.instances(male)
 for ind in male_individuals:
     print(ind)
 ```
 
 -----------------------------------------------------------------------
 
-In this guide we covered the main functionalities of the reasoners in Owlapy. More
-details are provided in the next guide.
+In this guide we covered the main functionalities of the reasoners in Owlapy. 
+In the next one, we speak about owlapi adaptor and how can make use of owlapi in owlapy.
 
 
 
diff --git a/examples/ontology_reasoning.py b/examples/ontology_reasoning.py
index 03959372..c48f655b 100644
--- a/examples/ontology_reasoning.py
+++ b/examples/ontology_reasoning.py
@@ -4,7 +4,7 @@
 from owlapy.owl_individual import OWLNamedIndividual
 from owlapy.owl_ontology_manager import OntologyManager
 from owlapy.owl_property import OWLDataProperty, OWLObjectProperty
-from owlapy.owl_reasoner import OntologyReasoner, SyncReasoner, BaseReasoner
+from owlapy.owl_reasoner import OntologyReasoner
 
 data_file = '../KGs/Test/test_ontology.owl'
 NS = 'http://www.semanticweb.org/stefan/ontologies/2023/1/untitled-ontology-11#'
@@ -130,7 +130,7 @@
 
 # ---------------------------------------- Reasoning ----------------------------------------
 
-reasoner = SyncReasoner(onto, BaseReasoner.HERMIT)
+reasoner = FastInstanceCheckerReasoner(onto)
 
 # Instances
 t1 = list(reasoner.instances(N))
diff --git a/examples/using_owlapi_adaptor.py b/examples/using_owlapi_adaptor.py
index 7c9dbaec..44d82039 100644
--- a/examples/using_owlapi_adaptor.py
+++ b/examples/using_owlapi_adaptor.py
@@ -20,11 +20,11 @@
 print("Individuals that are brother and father at the same time:")
 [print(_) for _ in instances]
 
-# Convert from owlapy to owlapi
-py_to_pi = adaptor.convert_to_owlapi(brother_and_father)
+# Map the class expression from owlapy to owlapi
+py_to_pi = adaptor.mapper.map_(brother_and_father)
 
-# Convert from owlapi to owlapy
-pi_to_py = adaptor.convert_from_owlapi(py_to_pi, "http://www.benchmark.org/family#")
+# Map the class expression from owlapi to owlapy
+pi_to_py = adaptor.mapper.map_(py_to_pi)
 print("----------------------")
 print(f"Owlapy ce: {pi_to_py}")
 
diff --git a/owlapy/iri.py b/owlapy/iri.py
index 2a65f33f..6fa36a05 100644
--- a/owlapy/iri.py
+++ b/owlapy/iri.py
@@ -156,14 +156,6 @@ def reminder(self) -> str:
         Returns:
             The string corresponding to the reminder of the IRI.
         """
-        return self.reminder()
-
-    def get_short_form(self) -> str:
-        """Gets the short form.
-
-        Returns:
-            A string that represents the short form.
-        """
         return self._remainder
 
     def get_namespace(self) -> str:
diff --git a/owlapy/owl_reasoner.py b/owlapy/owl_reasoner.py
index db5ba271..013a96c4 100644
--- a/owlapy/owl_reasoner.py
+++ b/owlapy/owl_reasoner.py
@@ -1,7 +1,5 @@
 """OWL Reasoner"""
 import operator
-import os
-import types
 from abc import ABCMeta, abstractmethod
 from collections import defaultdict
 from enum import Enum, auto
@@ -29,6 +27,7 @@
     OWLPropertyExpression, OWLDataPropertyExpression
 from owlapy.owl_individual import OWLNamedIndividual
 from owlapy.owl_literal import OWLLiteral
+from owlapy.owlapi_adaptor import OWLAPIAdaptor
 from owlapy.utils import LRUCache
 
 logger = logging.getLogger(__name__)
@@ -221,12 +220,6 @@ def object_property_values(self, ind: OWLNamedIndividual, pe: OWLObjectPropertyE
         """
         pass
 
-    @abstractmethod
-    def flush(self) -> None:
-        """Flushes any changes stored in the buffer, which causes the reasoner to take into consideration the changes
-        the current root ontology specified by the changes."""
-        pass
-
     @abstractmethod
     def instances(self, ce: OWLClassExpression, direct: bool = False) -> Iterable[OWLNamedIndividual]:
         """Gets the individuals which are instances of the specified class expression.
@@ -386,11 +379,6 @@ def get_root_ontology(self) -> OWLOntology:
         this ontology and its import's closure."""
         pass
 
-    @abstractmethod
-    def is_isolated(self):
-        """Return True if this reasoner is using an isolated ontology."""
-        pass
-
     @abstractmethod
     def super_classes(self, ce: OWLClassExpression, direct: bool = False, only_named: bool = True) \
             -> Iterable[OWLClassExpression]:
@@ -411,15 +399,16 @@ class expression with respect to the imports closure of the root ontology.
         pass
 
 
-class BaseReasoner(Enum):
-    """Enumeration class for base reasoner when calling sync_reasoner.
-
-    Attributes:
-        PELLET: Pellet base reasoner.
-        HERMIT: HermiT base reasoner.
-    """
-    PELLET = auto()
-    HERMIT = auto()
+# Deprecated
+# class BaseReasoner(Enum):
+#     """Enumeration class for base reasoner when calling sync_reasoner.
+#
+#     Attributes:
+#         PELLET: Pellet base reasoner.
+#         HERMIT: HermiT base reasoner.
+#     """
+#     PELLET = auto()
+#     HERMIT = auto()
 
 
 class OWLReasonerEx(OWLReasoner, metaclass=ABCMeta):
@@ -510,57 +499,18 @@ class OntologyReasoner(OWLReasonerEx):
     _ontology: Ontology
     _world: owlready2.World
 
-    def __init__(self, ontology: Ontology, isolate: bool = False):
+    def __init__(self, ontology: Ontology):
         """
         Base reasoner in Ontolearn, used to reason in the given ontology.
 
         Args:
             ontology: The ontology that should be used by the reasoner.
-            isolate: Whether to isolate the reasoner in a new world + copy of the original ontology.
-                     Useful if you create multiple reasoner instances in the same script.
         """
         super().__init__(ontology)
         assert isinstance(ontology, Ontology)
-
-        if isolate:
-            self._isolated = True
-            new_manager = OntologyManager()
-            self._ontology = new_manager.load_ontology(ontology.get_original_iri())
-            self._world = new_manager._world
-            print("INFO  OWLReasoner    :: Using isolated ontology\n"
-                  "INFO  OWLReasoner    :: Changes you make in the original ontology won't be reflected to the isolated"
-                  " ontology\n"
-                  "INFO  OWLReasoner    :: To make changes on the isolated ontology use the method "
-                  "`update_isolated_ontology()`")
-
-        else:
-            self._isolated = False
-            self._ontology = ontology
-            self._world = ontology._world
-
-    def update_isolated_ontology(self, axioms_to_add: List[OWLAxiom] = None,
-                                 axioms_to_remove: List[OWLAxiom] = None):
-        """
-        Add or remove axioms to the isolated ontology that the reasoner is using.
-
-        Args:
-            axioms_to_add (List[OWLAxiom]): Axioms to add to the isolated ontology.
-            axioms_to_remove (List[OWLAxiom]): Axioms to remove from the isolated ontology.
-        """
-        if self._isolated:
-            if axioms_to_add is None and axioms_to_remove is None:
-                raise ValueError(f"At least one argument should be specified in method: "
-                                 f"{self.update_isolated_ontology.__name__}")
-            manager = self._ontology.get_owl_ontology_manager()
-            if axioms_to_add is not None:
-                for axiom in axioms_to_add:
-                    manager.add_axiom(self._ontology, axiom)
-            if axioms_to_remove is not None:
-                for axiom in axioms_to_remove:
-                    manager.remove_axiom(self._ontology, axiom)
-        else:
-            raise AssertionError(f"Misuse of method '{self.update_isolated_ontology.__name__}'. The reasoner is not "
-                                 f"using an isolated ontology.")
+        self._isolated = False
+        self._ontology = ontology
+        self._world = ontology._world
 
     def data_property_domains(self, pe: OWLDataProperty, direct: bool = False) -> Iterable[OWLClassExpression]:
         domains = {d.get_domain() for d in self.get_root_ontology().data_property_domain_axioms(pe)}
@@ -706,9 +656,6 @@ def object_property_values(self, ind: OWLNamedIndividual, pe: OWLObjectPropertyE
         else:
             raise NotImplementedError(pe)
 
-    def flush(self) -> None:
-        pass
-
     def instances(self, ce: OWLClassExpression, direct: bool = False) -> Iterable[OWLNamedIndividual]:
         if direct:
             if isinstance(ce, OWLClass):
@@ -981,17 +928,6 @@ def _sup_or_sub_data_properties(self, dp: OWLDataProperty, direct: bool = False,
             yield from self._sup_or_sub_data_properties_recursive(dp, seen_set, super_or_sub)
 
     def super_data_properties(self, dp: OWLDataProperty, direct: bool = False) -> Iterable[OWLDataProperty]:
-        """Gets the stream of 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.
-
-         Args:
-             dp (OWLDataProperty): The data property whose super properties are to be retrieved.
-             direct (bool): Specifies if the direct super properties should be retrieved (True) or if the all
-                            super properties (ancestors) should be retrieved (False).
-
-         Returns:
-             Iterable of super properties.
-         """
         yield from self._sup_or_sub_data_properties(dp, direct, "super")
 
     def sub_data_properties(self, dp: OWLDataProperty, direct: bool = False) -> Iterable[OWLDataProperty]:
@@ -1077,36 +1013,34 @@ def types(self, ind: OWLNamedIndividual, direct: bool = False) -> Iterable[OWLCl
                     yield OWLClass(IRI.create(c.iri))
                 # Anonymous classes are ignored
 
-    def _sync_reasoner(self, other_reasoner: BaseReasoner = None,
-                       infer_property_values: bool = True,
-                       infer_data_property_values: bool = True, debug: bool = False) -> None:
-        """Call Owlready2's sync_reasoner method, which spawns a Java process on a temp file to infer more.
-
-        Args:
-            other_reasoner: Set to BaseReasoner.PELLET (default) or BaseReasoner.HERMIT.
-            infer_property_values: Whether to infer property values.
-            infer_data_property_values: Whether to infer data property values (only for PELLET).
-        """
-        assert other_reasoner is None or isinstance(other_reasoner, BaseReasoner)
-        with self.get_root_ontology()._onto:
-            if other_reasoner == BaseReasoner.HERMIT:
-                owlready2.sync_reasoner_hermit(self._world, infer_property_values=infer_property_values, debug=debug)
-            else:
-                owlready2.sync_reasoner_pellet(self._world,
-                                               infer_property_values=infer_property_values,
-                                               infer_data_property_values=infer_data_property_values,
-                                               debug=debug)
+    # Deprecated
+    # def _sync_reasoner(self, other_reasoner: BaseReasoner = None,
+    #                    infer_property_values: bool = True,
+    #                    infer_data_property_values: bool = True, debug: bool = False) -> None:
+    #     """Call Owlready2's sync_reasoner method, which spawns a Java process on a temp file to infer more.
+    #
+    #     Args:
+    #         other_reasoner: Set to BaseReasoner.PELLET (default) or BaseReasoner.HERMIT.
+    #         infer_property_values: Whether to infer property values.
+    #         infer_data_property_values: Whether to infer data property values (only for PELLET).
+    #     """
+    #     assert other_reasoner is None or isinstance(other_reasoner, BaseReasoner)
+    #     with self.get_root_ontology()._onto:
+    #         if other_reasoner == BaseReasoner.HERMIT:
+    #             owlready2.sync_reasoner_hermit(self._world, infer_property_values=infer_property_values, debug=debug)
+    #         else:
+    #             owlready2.sync_reasoner_pellet(self._world,
+    #                                            infer_property_values=infer_property_values,
+    #                                            infer_data_property_values=infer_data_property_values,
+    #                                            debug=debug)
 
     def get_root_ontology(self) -> OWLOntology:
         return self._ontology
 
-    def is_isolated(self):
-        """Return True if this reasoner is using an isolated ontology."""
-        return self._isolated
-
 
 _P = TypeVar('_P', bound=OWLPropertyExpression)
 
+
 class FastInstanceCheckerReasoner(OWLReasonerEx):
     """Tries to check instances fast (but maybe incomplete)."""
     __slots__ = '_ontology', '_base_reasoner', \
@@ -1152,10 +1086,7 @@ def __init__(self, ontology: OWLOntology, base_reasoner: OWLReasoner, *,
                 :func:`OWLReasoner_FastInstanceChecker.instances` retrieval.
             """
         super().__init__(ontology)
-        if base_reasoner.is_isolated():
-            self._ontology = base_reasoner.get_root_ontology()
-        else:
-            self._ontology = ontology
+        self._ontology = ontology
         self._base_reasoner = base_reasoner
         self._property_cache = property_cache
         self._negation_default = negation_default
@@ -1185,13 +1116,6 @@ def reset(self):
         """The reset method shall reset any cached state."""
         self._init()
 
-    def is_isolated(self):
-        return self._base_reasoner.is_isolated()
-
-    def is_using_triplestore(self):
-        # TODO: Deprecated! Remove after it is removed from OWLReasoner in owlapy
-        pass
-
     def data_property_domains(self, pe: OWLDataProperty, direct: bool = False) -> Iterable[OWLClassExpression]:
         yield from self._base_reasoner.data_property_domains(pe, direct=direct)
 
@@ -1227,9 +1151,6 @@ def object_property_values(self, ind: OWLNamedIndividual, pe: OWLObjectPropertyE
             -> Iterable[OWLNamedIndividual]:
         yield from self._base_reasoner.object_property_values(ind, pe, direct)
 
-    def flush(self) -> None:
-        self._base_reasoner.flush()
-
     def instances(self, ce: OWLClassExpression, direct: bool = False) -> Iterable[OWLNamedIndividual]:
         if direct:
             if not self.__warned & 2:
@@ -1685,84 +1606,89 @@ def _retrieve_triples(self, pe: OWLPropertyExpression) -> Iterable:
         yield from relations
 
 
-class SyncReasoner(OntologyReasoner):
-    __slots__ = '_cnt', '_conv', '_base_reasoner'
+class SyncReasoner(OWLReasonerEx):
 
-    _conv: ToOwlready2
-    _base_reasoner: BaseReasoner
-
-    def __init__(self, ontology: Ontology, base_reasoner: Optional[BaseReasoner] = None,
-                 infer_property_values: bool = True, infer_data_property_values: bool = True, isolate: bool = False):
+    def __init__(self, ontology_path: str, reasoner="HermiT"):
         """
-        OWL Reasoner with support for Complex Class Expression Instances + sync_reasoner.
+        OWL reasoner that syncs to other reasoners like HermiT,Pellet,etc.
 
         Args:
-            ontology: The ontology that should be used by the reasoner.
-            base_reasoner: Set to BaseReasoner.PELLET (default) or BaseReasoner.HERMIT.
-            infer_property_values: Whether to infer property values.
-            infer_data_property_values: Whether to infer data property values (only for PELLET).
-            isolate: Whether to isolate the reasoner in a new world + copy of the original ontology.
-                     Useful if you create multiple reasoner instances in the same script.
+            ontology_path: Path of ontology that should be used by the reasoner.
+            reasoner: Choose from (case-sensitive): ["HermiT", "Pellet", "JFact", "Openllet"]. Default: "HermiT".
         """
+        self.manager = OntologyManager()
+        self.ontology = self.manager.load_ontology(IRI.create("file://" + ontology_path))
+        super().__init__(self.ontology)
+        self.adaptor = OWLAPIAdaptor(ontology_path, reasoner)
 
-        super().__init__(ontology, isolate)
-        if isolate:
-            new_manager = OntologyManager()
-            self.reference_ontology = new_manager.load_ontology(ontology.get_original_iri())
-            self.reference_iri = IRI.create(f'file:/isolated_ontology_{id(self.reference_ontology)}.owl')
-            new_manager.save_ontology(self.reference_ontology, self.reference_iri)
+    def instances(self, ce: OWLClassExpression, direct: bool = False) -> Iterable[OWLNamedIndividual]:
+        yield from self.adaptor.instances(ce, direct)
 
-        self._cnt = 1
-        self._conv = ToOwlready2(world=self._world)
-        self._base_reasoner = base_reasoner
-        self._sync_reasoner(self._base_reasoner, infer_property_values, infer_data_property_values)
-        self.infer_property_values = infer_property_values
-        self.infer_data_property_values = infer_data_property_values
-
-    def update_isolated_ontology(self, axioms_to_add: List[OWLAxiom] = None,
-                                 axioms_to_remove: List[OWLAxiom] = None):
-        if self._isolated:
-            if axioms_to_add is None and axioms_to_remove is None:
-                raise ValueError(f"At least one argument should be specified in method: "
-                                 f"{self.update_isolated_ontology.__name__}")
-            self._ontology = self.reference_ontology
-            super().update_isolated_ontology(axioms_to_add, axioms_to_remove)
-            self.reference_ontology.get_owl_ontology_manager().save_ontology(self._ontology, self.reference_iri)
-            new_manager = OntologyManager()
-            self._ontology = new_manager.load_ontology(IRI.create(f'file://isolated_ontology_'
-                                                                  f'{id(self.reference_ontology)}.owl'))
-            self._world = new_manager._world
-            self._sync_reasoner(self._base_reasoner, self.infer_property_values, self.infer_data_property_values)
-        else:
-            raise AssertionError(f"Misuse of method '{self.update_isolated_ontology.__name__}'. The reasoner is not "
-                                 f"using an isolated ontology.")
+    def data_property_domains(self, pe: OWLDataProperty, direct: bool = False) -> Iterable[OWLClassExpression]:
+        yield from self.adaptor.data_property_domains(pe, direct)
 
-    def instances(self, ce: OWLClassExpression, direct: bool = False) -> Iterable[OWLNamedIndividual]:
-        if direct:
-            logging.warning("direct not implemented")
-        with self._world.get_ontology("http://temp.classes/"):
-            temp_pred = cast(owlready2.ThingClass, types.new_class("TempCls%d" % self._cnt, (owlready2.owl.Thing,)))
-            temp_pred.equivalent_to = [self._conv.map_concept(ce)]
-            if self._base_reasoner == BaseReasoner.HERMIT:
-                owlready2.sync_reasoner_hermit(self._world.get_ontology("http://temp.classes/"),
-                                               self.infer_property_values)
-            else:
-                owlready2.sync_reasoner_pellet(self._world.get_ontology("http://temp.classes/"),
-                                               self.infer_property_values, self.infer_data_property_values)
-        instances = list(temp_pred.instances(world=self._world))
-        temp_pred.equivalent_to = []
-        try:
-            owlready2.destroy_entity(temp_pred)
-        except AttributeError as e:
-            logger.info(f"AttributeError: {e} Source: {__file__} (you can ignore this)")
-        self._cnt += 1
-        for i in instances:
-            yield OWLNamedIndividual(IRI.create(i.iri))
-
-    def __del__(self):
-        if self._isolated:
-            file_path = f"isolated_ontology_{id(self.reference_ontology)}.owl"
-            try:
-                os.remove(file_path)
-            except OSError as e:
-                logger.warning(f"Error deleting {file_path}: {e}")
+    def object_property_domains(self, pe: OWLObjectProperty, direct: bool = False) -> Iterable[OWLClassExpression]:
+        yield from self.adaptor.object_property_domains(pe, direct)
+
+    def object_property_ranges(self, pe: OWLObjectProperty, direct: bool = False) -> Iterable[OWLClassExpression]:
+        yield from self.adaptor.object_property_ranges(pe, direct)
+
+    def equivalent_classes(self, ce: OWLClassExpression, only_named: bool = True) -> Iterable[OWLClassExpression]:
+        yield from self.adaptor.equivalent_classes(ce)
+
+    def disjoint_classes(self, ce: OWLClassExpression, only_named: bool = True) -> Iterable[OWLClassExpression]:
+        yield from self.adaptor.disjoint_classes(ce)
+
+    def different_individuals(self, ind: OWLNamedIndividual) -> Iterable[OWLNamedIndividual]:
+        yield from self.adaptor.different_individuals(ind)
+
+    def same_individuals(self, ind: OWLNamedIndividual) -> Iterable[OWLNamedIndividual]:
+        yield from self.adaptor.same_individuals(ind)
+
+    def data_property_values(self, ind: OWLNamedIndividual, pe: OWLDataProperty, direct: bool = True) -> Iterable[
+        OWLLiteral]:
+        yield from self.adaptor.data_property_values(ind, pe)
+
+    def object_property_values(self, ind: OWLNamedIndividual, pe: OWLObjectPropertyExpression, direct: bool = False) -> \
+            Iterable[OWLNamedIndividual]:
+        yield from self.adaptor.object_property_values(ind, pe)
+
+    def sub_classes(self, ce: OWLClassExpression, direct: bool = False, only_named: bool = True) -> Iterable[
+        OWLClassExpression]:
+        yield from self.adaptor.sub_classes(ce, direct)
+
+    def super_classes(self, ce: OWLClassExpression, direct: bool = False, only_named: bool = True) -> Iterable[
+        OWLClassExpression]:
+        yield from self.adaptor.super_classes(ce, direct)
+
+    def equivalent_object_properties(self, op: OWLObjectPropertyExpression) -> Iterable[OWLObjectPropertyExpression]:
+        yield from self.adaptor.equivalent_object_properties(op)
+
+    def equivalent_data_properties(self, dp: OWLDataProperty) -> Iterable[OWLDataProperty]:
+        yield from self.adaptor.equivalent_data_properties(dp)
+
+    def disjoint_object_properties(self, op: OWLObjectPropertyExpression) -> Iterable[OWLObjectPropertyExpression]:
+        yield from self.adaptor.disjoint_object_properties(op)
+
+    def disjoint_data_properties(self, dp: OWLDataProperty) -> Iterable[OWLDataProperty]:
+        yield from self.adaptor.disjoint_data_properties(dp)
+
+    def super_data_properties(self, dp: OWLDataProperty, direct: bool = False) -> Iterable[OWLDataProperty]:
+        yield from self.adaptor.super_data_properties(dp, direct)
+
+    def sub_data_properties(self, dp: OWLDataProperty, direct: bool = False) -> Iterable[OWLDataProperty]:
+        yield from self.adaptor.sub_data_properties(dp, direct)
+
+    def super_object_properties(self, op: OWLObjectPropertyExpression, direct: bool = False) -> Iterable[
+        OWLObjectPropertyExpression]:
+        yield from self.adaptor.super_object_properties(op, direct)
+
+    def sub_object_properties(self, op: OWLObjectPropertyExpression, direct: bool = False) -> Iterable[
+        OWLObjectPropertyExpression]:
+        yield from self.adaptor.sub_object_properties(op, direct)
+
+    def types(self, ind: OWLNamedIndividual, direct: bool = False) -> Iterable[OWLClass]:
+        yield from self.adaptor.types(ind, direct)
+
+    def get_root_ontology(self) -> OWLOntology:
+        return self.ontology
\ No newline at end of file
diff --git a/owlapy/owlapi_adaptor.py b/owlapy/owlapi_adaptor.py
index 5a0f540c..1f24ea3a 100644
--- a/owlapy/owlapi_adaptor.py
+++ b/owlapy/owlapi_adaptor.py
@@ -1,15 +1,22 @@
+"""Owlapi Adaptor
+
+Part of the docstrings are taken directly from owlapi
+"""
 import jpype.imports
 import os
 import pkg_resources
 
-from owlapy import manchester_to_owl_expression
 from owlapy.class_expression import OWLClassExpression
-from owlapy.iri import IRI
 from owlapy.owl_individual import OWLNamedIndividual
-from owlapy.render import owl_expression_to_manchester
+from owlapy.owl_property import OWLDataProperty, OWLObjectProperty
 from typing import List
 
 
+def to_list(stream_obj):
+    """Converts Java Stream object to Python list"""
+    return stream_obj.collect(jpype.JClass("java.util.stream.Collectors").toList())
+
+
 class OWLAPIAdaptor:
     """
     A class to interface with the OWL API using the HermiT reasoner, enabling ontology management,
@@ -21,8 +28,6 @@ class OWLAPIAdaptor:
         manager: The OWL ontology manager.
         ontology: The loaded OWL ontology.
         reasoner: Choose from (case-sensitive): ["HermiT", "Pellet", "JFact", "Openllet"]. Default: "HermiT".
-        parser: The Manchester OWL Syntax parser.
-        renderer: The Manchester OWL Syntax renderer.
     """
 
     def __init__(self, path: str, name_reasoner: str = "HermiT"):
@@ -39,7 +44,8 @@ def __init__(self, path: str, name_reasoner: str = "HermiT"):
         """
         self.path = path
         assert name_reasoner in ["HermiT", "Pellet", "JFact", "Openllet"], \
-            f"'{name_reasoner}' is not implemented. Available reasoners: ['HermiT', 'Pellet', 'JFact', 'Openllet']"
+            (f"'{name_reasoner}' is not implemented. Available reasoners: ['HermiT', 'Pellet', 'JFact', 'Openllet']. "
+             f"This field is case sensitive.")
         self.name_reasoner = name_reasoner
         # Attributes are initialized as JVM is started
         # () Manager is needed to load an ontology
@@ -48,9 +54,8 @@ def __init__(self, path: str, name_reasoner: str = "HermiT"):
         self.ontology = None
         # () Create a reasoner for the loaded ontology
         self.reasoner = None
-        self.parser = None
-        # () A manchester renderer to render owlapi ce to manchester syntax
-        self.renderer = None
+        # () For mapping entities/expressions from/to owlapi
+        self.mapper = None
         # () Set up the necessary attributes by making use of the java packages
         self._setup()
 
@@ -76,7 +81,8 @@ def _setup(self):
         if not jpype.isJVMStarted():
             self._startJVM()
 
-        # Import Java classes
+        # Imports
+        from owlapy.owlapi_mapper import OWLAPIMapper
         from org.semanticweb.owlapi.apibinding import OWLManager
         from java.io import File
         if self.name_reasoner == "HermiT":
@@ -90,18 +96,12 @@ def _setup(self):
         else:
             raise NotImplementedError("Not implemented")
 
-        from org.semanticweb.owlapi.manchestersyntax.parser import ManchesterOWLSyntaxClassExpressionParser
-        from org.semanticweb.owlapi.util import BidirectionalShortFormProviderAdapter, SimpleShortFormProvider, \
-            InferredSubClassAxiomGenerator, InferredClassAssertionAxiomGenerator
-
-        from org.semanticweb.owlapi.expression import ShortFormEntityChecker
-        from java.util import HashSet, ArrayList
-        from org.semanticweb.owlapi.manchestersyntax.renderer import ManchesterOWLSyntaxOWLObjectRendererImpl
-
         # () Manager is needed to load an ontology
         self.manager = OWLManager.createOWLOntologyManager()
         # () Load a local ontology using the manager
         self.ontology = self.manager.loadOntologyFromOntologyDocument(File(self.path))
+        self.mapper = OWLAPIMapper(self.ontology)
+
         # () Create a reasoner for the loaded ontology
         if self.name_reasoner == "HermiT":
             self.reasoner = ReasonerFactory().createReasoner(self.ontology)
@@ -113,23 +113,349 @@ def _setup(self):
         elif self.name_reasoner == "Openllet":
             self.reasoner = OpenlletReasonerFactory().getInstance().createReasoner(self.ontology)
 
-        # () Create a manchester parser and all the necessary attributes for parsing a manchester string to owlapi ce
-        ontology_set = HashSet()
-        ontology_set.add(self.ontology)
-        bidi_provider = BidirectionalShortFormProviderAdapter(self.manager, ontology_set, SimpleShortFormProvider())
-        entity_checker = ShortFormEntityChecker(bidi_provider)
-        self.parser = ManchesterOWLSyntaxClassExpressionParser(self.manager.getOWLDataFactory(), entity_checker)
-        # A manchester renderer to render owlapi ce to manchester syntax
-        self.renderer = ManchesterOWLSyntaxOWLObjectRendererImpl()
+    def has_consistent_ontology(self) -> bool:
+        """
+        Check if the used ontology is consistent.
+
+        Returns:
+            bool: True if the ontology is consistent, False otherwise.
+        """
+        return self.reasoner.isConsistent()
+
+    def instances(self, ce: OWLClassExpression, direct=False) -> List[OWLNamedIndividual]:
+        """
+        Get the instances for a given class expression using HermiT.
+
+        Args:
+            ce (OWLClassExpression): The class expression in OWLAPY format.
+            direct (bool): Whether to get direct instances or not. Defaults to False.
+
+        Returns:
+            list: A list of individuals classified by the given class expression.
+        """
+        inds = self.reasoner.getInstances(self.mapper.map_(ce), direct).getFlattened()
+        return [self.mapper.map_(ind) for ind in inds]
+
+    def equivalent_classes(self, ce: OWLClassExpression) -> List[OWLClassExpression]:
+        """
+        Gets the set of named classes that are equivalent to the specified class expression with
+        respect to the set of reasoner axioms.
+
+        Args:
+            ce (OWLClassExpression): The class expression whose equivalent classes are to be retrieved.
+
+        Returns:
+            Equivalent classes of the given class expression.
+        """
+        classes = self.reasoner.getEquivalentClasses(self.mapper.map_(ce)).getEntities()
+        yield from [self.mapper.map_(cls) for cls in classes]
+
+    def disjoint_classes(self, ce: OWLClassExpression) -> List[OWLClassExpression]:
+        """
+        Gets the classes that are disjoint with the specified class expression.
+
+        Args:
+            ce (OWLClassExpression): The class expression whose disjoint classes are to be retrieved.
+
+        Returns:
+            Disjoint classes of the given class expression.
+        """
+        classes = self.reasoner.getDisjointClasses(self.mapper.map_(ce)).getFlattened()
+        yield from [self.mapper.map_(cls) for cls in classes]
+
+    def sub_classes(self, ce: OWLClassExpression, direct=False) -> List[OWLClassExpression]:
+        """
+         Gets the set of named classes that are the strict (potentially direct) subclasses of the
+         specified class expression with respect to the reasoner axioms.
+
+         Args:
+             ce (OWLClassExpression): The class expression whose strict (direct) subclasses are to be retrieved.
+             direct (bool, optional): Specifies if the direct subclasses should be retrieved (True) or if
+                all subclasses (descendant) classes should be retrieved (False). Defaults to False.
+        Returns:
+            The subclasses of the given class expression depending on `direct` field.
+        """
+        classes = self.reasoner.getSubClasses(self.mapper.map_(ce), direct).getFlattened()
+        yield from [self.mapper.map_(cls) for cls in classes]
+
+    def super_classes(self, ce: OWLClassExpression, direct=False) -> List[OWLClassExpression]:
+        """
+        Gets the stream 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.
+
+        Args:
+             ce (OWLClassExpression): The class expression whose strict (direct) subclasses are to be retrieved.
+             direct (bool, optional): Specifies if the direct superclasses should be retrieved (True) or if
+                all superclasses (descendant) classes should be retrieved (False). Defaults to False.
+
+        Returns:
+            The subclasses of the given class expression depending on `direct` field.
+        """
+        classes = self.reasoner.getSuperClasses(self.mapper.map_(ce), direct).getFlattened()
+        yield from [self.mapper.map_(cls) for cls in classes]
+
+    def data_property_domains(self, p: OWLDataProperty, direct: bool = False):
+        """Gets the class expressions that are the direct or indirect domains of this property with respect to the
+           imports closure of the root ontology.
+
+        Args:
+            p: 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 = equivalent_classes(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
+            super_classes(DataSomeValuesFrom(pe rdfs:Literal), true). If direct is False: then the result of
+            super_classes(DataSomeValuesFrom(pe rdfs:Literal), false) together with N if N is non-empty.
+            (Note, rdfs:Literal is the top datatype).
+        """
+        yield from [self.mapper.map_(ce) for ce in
+                    self.reasoner.getDataPropertyDomains(self.mapper.map_(p), direct).getFlattened()]
+
+    def object_property_domains(self, p: OWLObjectProperty, direct: bool = False):
+        """Gets the class expressions that are the direct or indirect domains of this property with respect to the
+           imports closure of the root ontology.
+
+        Args:
+            p: 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 = equivalent_classes(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
+            super_classes(ObjectSomeValuesFrom(pe owl:Thing), true). If direct is False: then the result of
+            super_classes(ObjectSomeValuesFrom(pe owl:Thing), false) together with N if N is non-empty.
+        """
+        yield from [self.mapper.map_(ce) for ce in
+                    self.reasoner.getObjectPropertyDomains(self.mapper.map_(p), direct).getFlattened()]
+
+    def object_property_ranges(self, p: OWLObjectProperty, direct: bool = False):
+        """Gets the class expressions that are the direct or indirect ranges of this property with respect to the
+           imports closure of the root ontology.
+
+        Args:
+            p: 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 = equivalent_classes(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
+            super_classes(ObjectSomeValuesFrom(ObjectInverseOf(pe) owl:Thing), true). If direct is False: then
+            the result of super_classes(ObjectSomeValuesFrom(ObjectInverseOf(pe) owl:Thing), false) together with N
+            if N is non-empty.
+        """
+        yield from [self.mapper.map_(ce) for ce in
+                    self.reasoner.getObjectPropertyRanges(self.mapper.map_(p), direct).getFlattened()]
+
+    def sub_object_properties(self, p: OWLObjectProperty, direct: bool = False):
+        """Gets the stream 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.
+
+        Args:
+            p: The object property expression whose strict (direct) subproperties are to be retrieved.
+            direct: Specifies if the direct subproperties should be retrieved (True) or if the all subproperties
+                (descendants) should be retrieved (False).
+
+        Returns:
+            If direct is True, simplified object property expressions, such that for each simplified object property
+            expression, P, the set of reasoner axioms entails DirectSubObjectPropertyOf(P, pe).
+            If direct is False, simplified object property expressions, such that for each simplified object property
+            expression, P, the set of reasoner axioms entails StrictSubObjectPropertyOf(P, pe).
+            If pe is equivalent to owl:bottomObjectProperty then nothing will be returned.
+        """
+        yield from [self.mapper.map_(pe) for pe in
+                    self.reasoner.getSubObjectProperties(self.mapper.map_(p), direct).getFlattened()]
+
+    def super_object_properties(self, p: OWLObjectProperty, direct: bool = False):
+        """Gets the stream of object properties that are the strict (potentially direct) super properties of the
+         specified object property with respect to the imports closure of the root ontology.
+
+         Args:
+             p (OWLObjectPropertyExpression): The object property expression whose super properties are to be
+                                                retrieved.
+             direct (bool): Specifies if the direct super properties should be retrieved (True) or if the all
+                            super properties (ancestors) should be retrieved (False).
+
+         Returns:
+             Iterable of super properties.
+         """
+        yield from [self.mapper.map_(pe) for pe in
+                    self.reasoner.getSuperObjectProperties(self.mapper.map_(p), direct).getFlattened()]
+
+    def sub_data_properties(self, p: OWLDataProperty, direct: bool = False):
+        """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.
+
+        Args:
+            p: The data property whose strict (direct) subproperties are to be retrieved.
+            direct: Specifies if the direct subproperties should be retrieved (True) or if the all subproperties
+                (descendants) should be retrieved (False).
+
+        Returns:
+            If direct is True, each property P where the set of reasoner axioms entails DirectSubDataPropertyOf(P, pe).
+            If direct is False, each property P where the set of reasoner axioms entails
+            StrictSubDataPropertyOf(P, pe). If pe is equivalent to owl:bottomDataProperty then nothing will be
+            returned.
+        """
+        yield from [self.mapper.map_(pe) for pe in
+                    self.reasoner.getSubDataProperties(self.mapper.map_(p), direct).getFlattened()]
+
+    def super_data_properties(self, p: OWLDataProperty, direct: bool = False):
+        """Gets the stream of 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.
+
+         Args:
+             p (OWLDataProperty): The data property whose super properties are to be retrieved.
+             direct (bool): Specifies if the direct super properties should be retrieved (True) or if the all
+                            super properties (ancestors) should be retrieved (False).
+
+         Returns:
+             Iterable of super properties.
+         """
+        yield from [self.mapper.map_(pe) for pe in
+                    self.reasoner.getSuperDataProperties(self.mapper.map_(p), direct).getFlattened()]
+
+    def different_individuals(self, i: OWLNamedIndividual):
+        """Gets the individuals that are different from the specified individual with respect to the set of
+        reasoner axioms.
+
+        Args:
+            i: The individual whose different individuals are to be retrieved.
+
+        Returns:
+            All individuals x where the set of reasoner axioms entails DifferentIndividuals(ind x).
+        """
+        yield from [self.mapper.map_(ind) for ind in
+                    self.reasoner.getDifferentIndividuals(self.mapper.map_(i)).getFlattened()]
+
+    def same_individuals(self, i: OWLNamedIndividual):
+        """Gets the individuals that are the same as the specified individual with respect to the set of
+        reasoner axioms.
+
+        Args:
+            i: The individual whose same individuals are to be retrieved.
+
+        Returns:
+            All individuals x where the root ontology imports closure entails SameIndividual(ind x).
+        """
+        yield from [self.mapper.map_(ind) for ind in
+                    to_list(self.reasoner.sameIndividuals(self.mapper.map_(i)))]
+
+    def equivalent_object_properties(self, p: OWLObjectProperty):
+        """Gets the simplified object properties that are equivalent to the specified object property with respect
+        to the set of reasoner axioms.
+
+        Args:
+            p: The object property whose equivalent object properties are to be retrieved.
+
+        Returns:
+            All simplified object properties e where the root ontology imports closure entails
+            EquivalentObjectProperties(op e). If op is unsatisfiable with respect to the set of reasoner axioms
+            then owl:bottomDataProperty will be returned.
+        """
+        yield from [self.mapper.map_(pe) for pe in
+                    to_list(self.reasoner.equivalentObjectProperties(self.mapper.map_(p)))]
+
+    def equivalent_data_properties(self, p: OWLDataProperty):
+        """Gets the data properties that are equivalent to the specified data property with respect to the set of
+        reasoner axioms.
+
+        Args:
+            p: The data property whose equivalent data properties are to be retrieved.
+
+        Returns:
+            All data properties e where the root ontology imports closure entails EquivalentDataProperties(dp e).
+            If dp is unsatisfiable with respect to the set of reasoner axioms then owl:bottomDataProperty will
+            be returned.
+        """
+        yield from [self.mapper.map_(pe) for pe in
+                    to_list(self.reasoner.getEquivalentDataProperties(self.mapper.map_(p)))]
+
+    def object_property_values(self, i: OWLNamedIndividual, p: OWLObjectProperty):
+        """Gets the object property values for the specified individual and object property expression.
+
+        Args:
+            i: The individual that is the subject of the object property values.
+            p: The object property expression whose values are to be retrieved for the specified individual.
+
+        Returns:
+            The named individuals such that for each individual j, the set of reasoner axioms entails
+            ObjectPropertyAssertion(pe ind j).
+        """
+        yield from [self.mapper.map_(ind) for ind in
+                    self.reasoner.getObjectPropertyValues(self.mapper.map_(i), self.mapper.map_(p)).getFlattened()]
+
+    def data_property_values(self, i: OWLNamedIndividual, p: OWLDataProperty):
+        """Gets the data property values for the specified individual and data property expression.
+
+        Args:
+            i: The individual that is the subject of the data property values.
+            p: The data property expression whose values are to be retrieved for the specified individual.
+
+        Returns:
+            A set of OWLLiterals containing literals such that for each literal l in the set, the set of reasoner
+            axioms entails DataPropertyAssertion(pe ind l).
+        """
+        yield from [self.mapper.map_(literal) for literal in
+                    to_list(self.reasoner.dataPropertyValues(self.mapper.map_(i), self.mapper.map_(p)))]
+
+    def disjoint_object_properties(self, p: OWLObjectProperty):
+        """Gets the simplified object properties that are disjoint with the specified object property with respect
+        to the set of reasoner axioms.
 
-    def infer_and_save(self, output_path:str=None, output_format:str=None, inference_types:list[str]=None):
+        Args:
+            p: The object property whose disjoint object properties are to be retrieved.
+
+        Returns:
+            All simplified object properties e where the root ontology imports closure entails
+            EquivalentObjectProperties(e ObjectPropertyComplementOf(op)) or
+            StrictSubObjectPropertyOf(e ObjectPropertyComplementOf(op)).
+        """
+        yield from [self.mapper.map_(pe) for pe in
+                    self.reasoner.getDisjointObjectProperties(self.mapper.map_(p)).getFlattened()]
+
+    def disjoint_data_properties(self, p: OWLDataProperty):
+        """Gets the data properties that are disjoint with the specified data property with respect
+        to the set of reasoner axioms.
+
+        Args:
+            p: The data property whose disjoint data properties are to be retrieved.
+
+        Returns:
+            All data properties e where the root ontology imports closure entails
+            EquivalentDataProperties(e DataPropertyComplementOf(dp)) or
+            StrictSubDataPropertyOf(e DataPropertyComplementOf(dp)).
+        """
+        yield from [self.mapper.map_(pe) for pe in
+                    self.reasoner.getDisjointDataProperties(self.mapper.map_(p)).getFlattened()]
+
+    def types(self, i: OWLNamedIndividual, direct: bool = False):
+        """Gets the named classes which are (potentially direct) types of the specified named individual.
+
+        Args:
+            i: 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, each named class C where the set of reasoner axioms entails
+            DirectClassAssertion(C, ind). If direct is False, each named class C where the set of reasoner axioms
+            entails ClassAssertion(C, ind).
+        """
+        yield from [self.mapper.map_(ind) for ind in
+                    self.reasoner.getTypes(self.mapper.map_(i), direct).getFlattened()]
+
+    def infer_and_save(self, output_path: str = None, output_format: str = None, inference_types: list[str] = None):
         from java.io import File, FileOutputStream
         from java.util import ArrayList
         from org.semanticweb.owlapi.util import InferredSubClassAxiomGenerator, InferredClassAssertionAxiomGenerator
         from org.semanticweb.owlapi.util import InferredOntologyGenerator, InferredEquivalentClassAxiomGenerator,InferredInverseObjectPropertiesAxiomGenerator
         from org.semanticweb.owlapi.util import InferredDisjointClassesAxiomGenerator
         from org.semanticweb.owlapi.formats import TurtleDocumentFormat, RDFXMLDocumentFormat, OWLXMLDocumentFormat
-
         if output_format == "ttl" or output_format == "turtle":
             document_format = TurtleDocumentFormat()
         elif output_format == "rdf/xml":
@@ -148,118 +474,37 @@ def infer_and_save(self, output_path:str=None, output_format:str=None, inference
         for i in inference_types:
             if java_object := inference_types_mapping.get(i, None):
                 generators.add(java_object)
-
         iog = InferredOntologyGenerator(self.reasoner, generators)
-        inferredAxiomsOntology = self.manager.createOntology()
-        iog.fillOntology(self.manager.getOWLDataFactory(), inferredAxiomsOntology);
-        inferredOntologyFile = File(output_path)
-        inferredOntologyFile = inferredOntologyFile.getAbsoluteFile()
-        outputStream = FileOutputStream(inferredOntologyFile)
-        self.manager.saveOntology(inferredAxiomsOntology, document_format, outputStream);
+        inferred_axioms_ontology = self.manager.createOntology()
+        iog.fillOntology(self.manager.getOWLDataFactory(), inferred_axioms_ontology)
+        inferred_ontology_file = File(output_path).getAbsoluteFile()
+        output_stream = FileOutputStream(inferred_ontology_file)
+        self.manager.saveOntology(inferred_axioms_ontology, document_format, output_stream)
 
     def generate_inferred_class_assertion_axioms(self, output="temp.ttl", output_format: str = None):
         """
         Generates inferred class assertion axioms for the ontology managed by this instance's reasoner and saves them to a file.
-
         This function uses the OWL API to generate inferred class assertion axioms based on the ontology and reasoner
         associated with this instance. The inferred axioms are saved to the specified output file in the desired format.
-
         Parameters:
         -----------
         output : str, optional
             The name of the file where the inferred axioms will be saved. Default is "temp.ttl".
-
         output_format : str, optional
             The format in which to save the inferred axioms. Supported formats are:
             - "ttl" or "turtle" for Turtle format
             - "rdf/xml" for RDF/XML format
             - "owl/xml" for OWL/XML format
             If not specified, the format of the original ontology is used.
-
         Notes:
         ------
         - The function supports saving in multiple formats: Turtle, RDF/XML, and OWL/XML.
         - The inferred axioms are generated using the reasoner associated with this instance and the OWL API's
           InferredClassAssertionAxiomGenerator.
         - The inferred axioms are added to a new ontology which is then saved in the specified format.
-
         Example:
         --------
         >>> instance.generate_inferred_class_assertion_axioms(output="inferred_axioms.ttl", format="ttl")
-
         This will save the inferred class assertion axioms to the file "inferred_axioms.ttl" in Turtle format.
-
-        """
-        from java.io import File, FileOutputStream
-        from java.util import ArrayList
-        from org.semanticweb.owlapi.util import InferredSubClassAxiomGenerator, InferredClassAssertionAxiomGenerator
-        from org.semanticweb.owlapi.util import InferredOntologyGenerator
-        from org.semanticweb.owlapi.formats import TurtleDocumentFormat, RDFXMLDocumentFormat, OWLXMLDocumentFormat
-        if format == "ttl" or format == "turtle":
-            document_format = TurtleDocumentFormat()
-        elif format == "rdf/xml":
-            document_format = RDFXMLDocumentFormat()
-        elif format == "owl/xml":
-            document_format = OWLXMLDocumentFormat()
-        else:
-            document_format = self.manager.getOntologyFormat(self.ontology)
-
-        generators = ArrayList()
-
-        # generators.add(InferredSubClassAxiomGenerator())
-        generators.add(InferredClassAssertionAxiomGenerator())
-
-        iog = InferredOntologyGenerator(self.reasoner, generators)
-        inferredAxiomsOntology = self.manager.createOntology()
-        iog.fillOntology(self.manager.getOWLDataFactory(), inferredAxiomsOntology);
-        inferredOntologyFile = File(output)
-        inferredOntologyFile = inferredOntologyFile.getAbsoluteFile()
-        outputStream = FileOutputStream(inferredOntologyFile)
-        self.manager.saveOntology(inferredAxiomsOntology, document_format, outputStream);
-
-    def convert_to_owlapi(self, ce: OWLClassExpression):
-        """
-        Converts an OWLAPY class expression to an OWLAPI class expression.
-
-        Args:
-            ce (OWLClassExpression): The class expression in OWLAPY format to be converted.
-
-        Returns:
-            The class expression in OWLAPI format.
-        """
-        return self.parser.parse(owl_expression_to_manchester(ce))
-
-    def convert_from_owlapi(self, ce, namespace: str) -> OWLClassExpression:
         """
-        Converts an OWLAPI class expression to an OWLAPY class expression.
-
-        Args:
-            ce: The class expression in OWLAPI format.
-            namespace (str): The ontology's namespace where the class expression belongs.
-
-        Returns:
-            OWLClassExpression: The class expression in OWLAPY format.
-        """
-        return manchester_to_owl_expression(str(self.renderer.render(ce)), namespace)
-
-    def instances(self, ce: OWLClassExpression) -> List[OWLNamedIndividual]:
-        """
-        Get the instances for a given class expression using HermiT.
-
-        Args:
-            ce (OWLClassExpression): The class expression in OWLAPY format.
-
-        Returns:
-            list: A list of individuals classified by the given class expression.
-        """
-        inds = self.reasoner.getInstances(self.convert_to_owlapi(ce), False).getFlattened()
-        return [OWLNamedIndividual(IRI.create(str(ind)[1:-1])) for ind in inds]
-
-    def has_consistent_ontology(self) -> bool:
-        """
-        Check if the used ontology is consistent.
-
-        Returns:
-            bool: True if the ontology is consistent, False otherwise.
-        """
-        return self.reasoner.isConsistent()
+        self.infer_and_save(output, output_format, ["InferredClassAssertionAxiomGenerator"])
diff --git a/owlapy/owlapi_mapper.py b/owlapy/owlapi_mapper.py
new file mode 100644
index 00000000..b2b82ec5
--- /dev/null
+++ b/owlapy/owlapi_mapper.py
@@ -0,0 +1,149 @@
+from functools import singledispatchmethod
+import jpype.imports
+
+from owlapy import owl_expression_to_manchester, manchester_to_owl_expression
+from owlapy.class_expression import OWLClassExpression
+from owlapy.iri import IRI
+from owlapy.owl_individual import OWLNamedIndividual
+from owlapy.owl_literal import OWLLiteral
+from owlapy.owl_property import OWLObjectProperty, OWLDataProperty
+
+if jpype.isJVMStarted():
+    from uk.ac.manchester.cs.owl.owlapi import OWLObjectPropertyImpl, OWLDataPropertyImpl, OWLNamedIndividualImpl
+    from org.semanticweb.owlapi.model import IRI as owlapi_IRI
+    from org.semanticweb.owlapi.manchestersyntax.parser import ManchesterOWLSyntaxClassExpressionParser
+    from org.semanticweb.owlapi.manchestersyntax.renderer import ManchesterOWLSyntaxOWLObjectRendererImpl
+    from org.semanticweb.owlapi.util import BidirectionalShortFormProviderAdapter, SimpleShortFormProvider
+    from org.semanticweb.owlapi.expression import ShortFormEntityChecker
+    from java.util import HashSet
+    from uk.ac.manchester.cs.owl.owlapi import (OWLAnonymousClassExpressionImpl, OWLCardinalityRestrictionImpl,
+                                                OWLClassExpressionImpl, OWLClassImpl, OWLDataAllValuesFromImpl,
+                                                OWLDataCardinalityRestrictionImpl, OWLDataExactCardinalityImpl,
+                                                OWLDataHasValueImpl, OWLDataMaxCardinalityImpl,
+                                                OWLDataMinCardinalityImpl, OWLDataSomeValuesFromImpl,
+                                                OWLNaryBooleanClassExpressionImpl, OWLObjectAllValuesFromImpl,
+                                                OWLObjectCardinalityRestrictionImpl, OWLObjectComplementOfImpl,
+                                                OWLObjectExactCardinalityImpl, OWLObjectHasSelfImpl,
+                                                OWLObjectHasValueImpl, OWLObjectIntersectionOfImpl,
+                                                OWLObjectMaxCardinalityImpl, OWLObjectMinCardinalityImpl,
+                                                OWLObjectOneOfImpl, OWLObjectSomeValuesFromImpl,
+                                                OWLObjectUnionOfImpl, OWLQuantifiedDataRestrictionImpl,
+                                                OWLQuantifiedObjectRestrictionImpl, OWLQuantifiedRestrictionImpl,
+                                                OWLValueRestrictionImpl, OWLLiteralImplBoolean, OWLLiteralImplString,
+                                                OWLLiteralImplDouble, OWLLiteralImplFloat, OWLLiteralImplInteger)
+else:
+    raise ImportError("Jpype JVM is not started! Tip: Import OWLAPIMapper after JVM has started")
+
+
+class OWLAPIMapper:
+
+    def __init__(self, ontology):
+        self.ontology = ontology
+        self.manager = ontology.getOWLOntologyManager()
+
+        # () Get the name space.
+        self.namespace = self.ontology.getOntologyID().getOntologyIRI().orElse(None)
+        if self.namespace is not None:
+            self.namespace = str(self.namespace)
+            if self.namespace[-1] not in ["/", "#", ":"]:
+                self.namespace += "#"
+        else:
+            self.namespace = "http://www.anonymous.org/anonymous#"
+
+        # () Create a manchester parser and a renderer.
+        ontology_set = HashSet()
+        ontology_set.add(self.ontology)
+        bidi_provider = BidirectionalShortFormProviderAdapter(self.manager, ontology_set, SimpleShortFormProvider())
+        entity_checker = ShortFormEntityChecker(bidi_provider)
+        self.parser = ManchesterOWLSyntaxClassExpressionParser(self.manager.getOWLDataFactory(), entity_checker)
+        self.renderer = ManchesterOWLSyntaxOWLObjectRendererImpl()
+
+    @singledispatchmethod
+    def map_(self, e):
+        """ (owlapy <--> owlapi) entity mapping.
+
+        Args:
+            e: OWL entity/expression.
+        """
+        raise NotImplementedError()
+
+    @map_.register
+    def _(self, e: OWLObjectProperty):
+        return OWLObjectPropertyImpl(owlapi_IRI.create(e.str))
+
+    @map_.register
+    def _(self, e: OWLObjectPropertyImpl):
+        return OWLObjectProperty(IRI.create(str(e.getIRI().getIRIString())))
+
+    @map_.register
+    def _(self, e: OWLDataProperty):
+        return OWLDataPropertyImpl(owlapi_IRI.create(e.str))
+
+    @map_.register
+    def _(self, e: OWLDataPropertyImpl):
+        return OWLDataProperty(IRI.create(str(e.getIRI().getIRIString())))
+
+    @map_.register
+    def _(self, e: OWLNamedIndividual):
+        return OWLNamedIndividualImpl(owlapi_IRI.create(e.str))
+
+    @map_.register
+    def _(self, e: OWLNamedIndividualImpl):
+        return OWLNamedIndividual(IRI.create(str(e.getIRI().getIRIString())))
+
+    @map_.register
+    def _(self, e: OWLClassExpression):
+        return self.parser.parse(owl_expression_to_manchester(e))
+
+    @map_.register(OWLAnonymousClassExpressionImpl)
+    @map_.register(OWLCardinalityRestrictionImpl)
+    @map_.register(OWLClassExpressionImpl)
+    @map_.register(OWLClassImpl)
+    @map_.register(OWLDataAllValuesFromImpl)
+    @map_.register(OWLDataCardinalityRestrictionImpl)
+    @map_.register(OWLDataExactCardinalityImpl)
+    @map_.register(OWLDataHasValueImpl)
+    @map_.register(OWLDataMaxCardinalityImpl)
+    @map_.register(OWLDataMinCardinalityImpl)
+    @map_.register(OWLDataSomeValuesFromImpl)
+    @map_.register(OWLNaryBooleanClassExpressionImpl)
+    @map_.register(OWLObjectAllValuesFromImpl)
+    @map_.register(OWLObjectCardinalityRestrictionImpl)
+    @map_.register(OWLObjectComplementOfImpl)
+    @map_.register(OWLObjectExactCardinalityImpl)
+    @map_.register(OWLObjectHasSelfImpl)
+    @map_.register(OWLObjectHasValueImpl)
+    @map_.register(OWLObjectIntersectionOfImpl)
+    @map_.register(OWLObjectMaxCardinalityImpl)
+    @map_.register(OWLObjectMinCardinalityImpl)
+    @map_.register(OWLObjectOneOfImpl)
+    @map_.register(OWLObjectSomeValuesFromImpl)
+    @map_.register(OWLObjectUnionOfImpl)
+    @map_.register(OWLQuantifiedDataRestrictionImpl)
+    @map_.register(OWLQuantifiedObjectRestrictionImpl)
+    @map_.register(OWLQuantifiedRestrictionImpl)
+    @map_.register(OWLValueRestrictionImpl)
+    def _(self, e):
+        # Cant recognize the classes as implementation of org.semanticweb.owlapi.model.OWLClassExpression, so we
+        # have to register all possible implementations
+        return manchester_to_owl_expression(str(self.renderer.render(e)), self.namespace)
+
+    @map_.register(OWLLiteralImplBoolean)
+    def _(self, e):
+        raw_value = str(e.getLiteral())
+        if raw_value.lower() == "true":
+            return OWLLiteral(True)
+        return OWLLiteral(False)
+
+    @map_.register(OWLLiteralImplDouble)
+    @map_.register(OWLLiteralImplFloat)
+    def _(self, e):
+        return OWLLiteral(float(str(e.getLiteral())))
+
+    @map_.register(OWLLiteralImplString)
+    def _(self, e):
+        return OWLLiteral(str(e.getLiteral()))
+
+    @map_.register(OWLLiteralImplInteger)
+    def _(self, e):
+        return OWLLiteral(int(str(e.getLiteral())))
diff --git a/owlapy/render.py b/owlapy/render.py
index 68874433..e756445f 100644
--- a/owlapy/render.py
+++ b/owlapy/render.py
@@ -49,7 +49,7 @@
 
 def _simple_short_form_provider(e: OWLEntity) -> str:
     iri: IRI = e.iri
-    sf = iri.get_short_form()
+    sf = iri.reminder
     for ns in [namespaces.XSD, namespaces.OWL, namespaces.RDFS, namespaces.RDF]:
         if iri.get_namespace() == ns:
             return "%s:%s" % (ns.prefix, sf)


Test patch:
diff --git a/tests/test_owlapi_adaptor.py b/tests/test_owlapi_adaptor.py
index 5864d5a2..47d5e9a2 100644
--- a/tests/test_owlapi_adaptor.py
+++ b/tests/test_owlapi_adaptor.py
@@ -76,14 +76,14 @@ def test_conversion(self):
         class_expression = data_factory.getOWLObjectIntersectionOf(nitrogen_class, some_values_from)
 
         # compare them with the adaptor converted expression
-        ce_converted = self.adaptor.convert_to_owlapi(self.ce)
+        ce_converted = self.adaptor.mapper.map_(self.ce)
         print(ce_converted)
         print(class_expression)
         self.assertEqual(class_expression, ce_converted)
 
         # convert back to owlapy and check for equality
-        ce_1 = self.adaptor.convert_from_owlapi(class_expression, self.ns)
-        ce_2 = self.adaptor.convert_from_owlapi(ce_converted, self.ns)
+        ce_1 = self.adaptor.mapper.map_(class_expression)
+        ce_2 = self.adaptor.mapper.map_(ce_converted)
 
         self.assertEqual(ce_1, ce_2)
         self.assertEqual(ce_1, self.ce)
diff --git a/tests/test_owlapy_ontology_management.py b/tests/test_owlapy_ontology_management.py
index 6eb09c3b..fefbf0c4 100644
--- a/tests/test_owlapy_ontology_management.py
+++ b/tests/test_owlapy_ontology_management.py
@@ -2,8 +2,7 @@
 import unittest
 
 from pandas import Timedelta
-from owlapy.owl_reasoner import FastInstanceCheckerReasoner, OntologyReasoner, \
-    SyncReasoner
+from owlapy.owl_reasoner import FastInstanceCheckerReasoner, OntologyReasoner, SyncReasoner
 from owlapy.providers import owl_datatype_max_inclusive_restriction, owl_datatype_min_inclusive_restriction, \
                               owl_datatype_min_max_exclusive_restriction, owl_datatype_min_max_inclusive_restriction
 
@@ -20,7 +19,7 @@
     OWLDifferentIndividualsAxiom, OWLDisjointClassesAxiom, OWLDisjointDataPropertiesAxiom, \
     OWLDisjointObjectPropertiesAxiom, OWLEquivalentDataPropertiesAxiom, OWLEquivalentObjectPropertiesAxiom, \
     OWLDataPropertyDomainAxiom, OWLDataPropertyRangeAxiom, OWLSubClassOfAxiom, OWLObjectPropertyDomainAxiom, \
-    OWLDataPropertyAssertionAxiom, OWLObjectPropertyAssertionAxiom, OWLDeclarationAxiom
+    OWLDataPropertyAssertionAxiom, OWLObjectPropertyAssertionAxiom
 from owlapy.owl_data_ranges import OWLDataComplementOf, OWLDataIntersectionOf, OWLDataUnionOf
 from owlapy.owl_individual import OWLNamedIndividual
 from owlapy.owl_literal import DoubleOWLDatatype, OWLLiteral, DurationOWLDatatype, IntegerOWLDatatype, \
@@ -800,19 +799,16 @@ def test_mapping_rev_data_properties(self):
         self.assertEqual(owl_ce, from_owlready.map_concept(ce))
 
 
-class Owlapy_Owlready2_ComplexCEInstances_Test(unittest.TestCase):
+class Owlapy_Owlready2_SyncReasoner(unittest.TestCase):
     # noinspection DuplicatedCode
     def test_instances(self):
         ns = "http://example.com/father#"
-        mgr = OntologyManager()
-        onto = mgr.load_ontology(IRI.create("file://KGs/Family/father.owl"))
 
         male = OWLClass(IRI.create(ns, 'male'))
         female = OWLClass(IRI.create(ns, 'female'))
         has_child = OWLObjectProperty(IRI(ns, 'hasChild'))
 
-        # reasoner = OWLReasoner_Owlready2(onto)
-        reasoner = SyncReasoner(onto)
+        reasoner = SyncReasoner("KGs/Family/father.owl")
 
         inst = frozenset(reasoner.instances(female))
         target_inst = frozenset({OWLNamedIndividual(IRI(ns, 'anna')),
@@ -829,34 +825,6 @@ def test_instances(self):
         target_inst = frozenset({OWLNamedIndividual(IRI(ns, 'anna'))})
         self.assertEqual(inst, target_inst)
 
-    def test_isolated_ontology(self):
-
-        ns = "http://example.com/father#"
-        mgr = OntologyManager()
-        onto = mgr.load_ontology(IRI.create("file://KGs/Family/father.owl"))
-
-        reasoner1 = OntologyReasoner(onto)
-        ccei_reasoner = SyncReasoner(onto, isolate=True)
-
-        new_individual = OWLNamedIndividual(IRI(ns, 'bob'))
-        male_ce = OWLClass(IRI(ns, "male"))
-        axiom1 = OWLDeclarationAxiom(new_individual)
-        axiom2 = OWLClassAssertionAxiom(new_individual, male_ce)
-        mgr.add_axiom(onto, axiom1)
-        mgr.add_axiom(onto, axiom2)
-
-        self.assertIn(new_individual, reasoner1.instances(male_ce))
-        self.assertNotIn(new_individual, ccei_reasoner.instances(male_ce))
-
-        ccei_reasoner.update_isolated_ontology(axioms_to_add=[axiom1, axiom2])
-
-        self.assertIn(new_individual, ccei_reasoner.instances(male_ce))
-
-        ccei_reasoner.update_isolated_ontology(axioms_to_remove=[axiom2, axiom1])
-
-        self.assertIn(new_individual, reasoner1.instances(male_ce))
-        self.assertNotIn(new_individual, ccei_reasoner.instances(male_ce))
-
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tests/test_owlapy_owl2sparql_converter.py b/tests/test_owlapy_owl2sparql_converter.py
index 6b5dd21b..f943f0e0 100644
--- a/tests/test_owlapy_owl2sparql_converter.py
+++ b/tests/test_owlapy_owl2sparql_converter.py
@@ -14,7 +14,7 @@
 from owlapy.converter import Owl2SparqlConverter
 from rdflib import Graph
 
-PATH_FAMILY = 'KGs/Family/family-benchmark_rich_background.owl'
+PATH_FAMILY = '../KGs/Family/family-benchmark_rich_background.owl'
 
 
 # checks whether all individuals returned by the reasoner are found in results generated by the sparql query
@@ -29,9 +29,9 @@ def check_reasoner_instances_in_sparql_results(sparql_results: rdflib.query.Resu
         else:
             sparql_results_set.add(individual_iri_str.split('/')[-1])
     for result in reasoner_results:
-        if result.iri.get_short_form() not in sparql_results_set:
+        if result.iri.reminder not in sparql_results_set:
             print()
-            print(result.iri.get_short_form(), "Not found in SPARQL results set")
+            print(result.iri.reminder, "Not found in SPARQL results set")
             return False
     return True