diff --git a/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/loader/BatchNeo4JIndexer.java b/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/loader/BatchNeo4JIndexer.java
index 473815e9..cef5bde4 100644
--- a/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/loader/BatchNeo4JIndexer.java
+++ b/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/loader/BatchNeo4JIndexer.java
@@ -1,21 +1,6 @@
 package uk.ac.ebi.spot.ols.loader;
 
-import static uk.ac.ebi.spot.ols.loader.Neo4JIndexerConstants.*;
-import static uk.ac.ebi.spot.ols.config.OntologyDefaults.THING;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-
-import org.neo4j.graphdb.DynamicLabel;
-import org.neo4j.graphdb.GraphDatabaseService;
-import org.neo4j.graphdb.Label;
-import org.neo4j.graphdb.Result;
-import org.neo4j.graphdb.Transaction;
+import org.neo4j.graphdb.*;
 import org.neo4j.graphdb.factory.GraphDatabaseFactory;
 import org.neo4j.graphdb.index.IndexHits;
 import org.neo4j.graphdb.schema.IndexDefinition;
@@ -30,12 +15,17 @@
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
-
 import uk.ac.ebi.spot.ols.config.OlsNeo4jConfiguration;
 import uk.ac.ebi.spot.ols.exception.IndexingException;
 import uk.ac.ebi.spot.ols.model.OntologyIndexer;
 import uk.ac.ebi.spot.ols.util.LocalizedStrings;
 
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+import static uk.ac.ebi.spot.ols.config.OntologyDefaults.THING;
+import static uk.ac.ebi.spot.ols.loader.Neo4JIndexerConstants.*;
+
 /**
  * @author Simon Jupp
  * @date 17/06/2015
@@ -110,7 +100,7 @@ private Long getOrCreateMergedNode(BatchInserter inserter, Map<String, Long> mer
                     }
                 }
 
-		properties.put("label", labels.getFirstString("en"));
+                properties.put("label", labels.getFirstString("en"));
 
                 Long hit = inserter.createNode(properties, nodeLabel);
                 index.add(hit, properties);
@@ -220,6 +210,11 @@ private void indexIndividuals(BatchInserter inserter, OntologyLoader loader,
 
         for (IRI individualIri : loader.getAllIndividualIRIs()) {
 
+            // avoid duplicating individuals already related to a class
+            if (classNodeMap.containsKey(individualIri.toString())) {
+                nodeMap.put(individualIri.toString(), classNodeMap.get(individualIri.toString()));
+            }
+
             Long node = NodeCreator.getOrCreateNode(inserter, nodeMap, loader, individualIri,
                     new LinkedList<Label>(Arrays.asList(instanceLabel, _instanceLabel,
                             nodeOntologyLabel)));
@@ -250,14 +245,19 @@ private void indexIndividuals(BatchInserter inserter, OntologyLoader loader,
             }
 
             // add relations
-            indexRelations(node, loader.getRelatedIndividuals(individualIri),
-                    inserter, loader, nodeMap,
-                    new LinkedList<Label>(Arrays.asList(instanceLabel, nodeOntologyLabel, _instanceLabel)));
-
             indexRelations(node, loader.getRelatedClassesToIndividual(individualIri),
                     inserter, loader, classNodeMap,
                     new LinkedList<Label>(Arrays.asList(nodeLabel, nodeOntologyLabel, _nodeLabel)));
         }
+
+        // add related individuals only after indexing all individuals to avoid duplication
+        for (IRI individualIri : loader.getAllIndividualIRIs()) {
+            if (loader.getRelatedIndividuals(individualIri).size() > 0) {
+                indexRelations(nodeMap.get(individualIri.toString()), loader.getRelatedIndividuals(individualIri),
+                        inserter, loader, nodeMap,
+                        new LinkedList<Label>(Arrays.asList(instanceLabel, nodeOntologyLabel, _instanceLabel)));
+            }
+        }
     }
 
     private void indexRelations(Long node, Map<IRI, Collection<IRI>> relatedIndividuals,
@@ -429,7 +429,7 @@ private static void addLocalizedProperties(
 
         properties.put(propertyName, localizedStrings.getFirstString("en"));
 
-        for(String language : localizedStrings.getLanguages()) {
+        for (String language : localizedStrings.getLanguages()) {
             properties.put(propertyName + "_" + language, localizedStrings.getFirstString(language));
         }
     }
@@ -449,7 +449,7 @@ public void createIndex(Collection<OntologyLoader> loaders) throws IndexingExcep
         for (OntologyLoader loader : loaders) {
 
             BatchInserter inserter = getBatchIndexer(loader.getOntologyName());
-            
+
             setOntologyLabel(loader.getOntologyName());
             // index classes
             indexClasses(inserter, loader, classNodeMap, mergedNodeMap);
@@ -492,27 +492,24 @@ public void createIndex(Collection<OntologyLoader> loaders) throws IndexingExcep
                     } catch (IllegalStateException e) {
                         throw new IndexingException("Building Neo4j index failed as the schema index didn't finish in time", e);
                     }
-                }
-                else if (state.equals(Schema.IndexState.FAILED)) {
+                } else if (state.equals(Schema.IndexState.FAILED)) {
                     throw new Exception("Index failed: " + indexDefinition.getLabel().name());
                 }
             }
 
             tx.success();
-        }
-        catch (Exception e) {
-        	logger.debug(e.getMessage(), e);
+        } catch (Exception e) {
+            logger.debug(e.getMessage(), e);
             tx.failure();
             throw new IndexingException("Building Neo4j index failed as the schema index creation failed", e);
-        }
-        finally {
+        } finally {
             tx.close();
             db.shutdown();
         }
     }
 
-    protected GraphDatabaseService getGraphDatabase () {
-   		return new GraphDatabaseFactory().newEmbeddedDatabase(neo4jConfiguration.getNeo4JPath());
+    protected GraphDatabaseService getGraphDatabase() {
+        return new GraphDatabaseFactory().newEmbeddedDatabase(neo4jConfiguration.getNeo4JPath());
     }
 
     public void dropIndex(OntologyLoader loader) throws IndexingException {
@@ -538,14 +535,14 @@ private void deleteNodes(String ontologyName) {
         int count = getNodeCount(
                 "match (n:" + ontologyName.toUpperCase() + ")-[r]->() return count(r) as count", ontologyName);
 
-        for (int x = 0; x < count ; x +=DELETE_SIZE) {
+        for (int x = 0; x < count; x += DELETE_SIZE) {
 
             Transaction tx = db.beginTx();
 
             try {
                 String cypherDelete =
-                        "match (n:" + ontologyName.toUpperCase() + ")-[r]->() with r limit " + 
-                        		DELETE_SIZE + " delete r";
+                        "match (n:" + ontologyName.toUpperCase() + ")-[r]->() with r limit " +
+                                DELETE_SIZE + " delete r";
                 getLogger().info("executing delete: " + cypherDelete);
                 Result result = db.execute(cypherDelete);
                 getLogger().info(result.resultAsString());
@@ -561,7 +558,7 @@ private void deleteNodes(String ontologyName) {
         count = getNodeCount(
                 "match (n:" + ontologyName.toUpperCase() + ") return count(n) as count", ontologyName
         );
-        for (int x = 0; x < count ; x +=DELETE_SIZE) {
+        for (int x = 0; x < count; x += DELETE_SIZE) {
 
             Transaction tx = db.beginTx();
 
@@ -593,12 +590,10 @@ private int getNodeCount(String nodeCountCypher, String ontologyName) {
             count = (Long) result.next().get("count");
             getLogger().debug("query count " + count);
             tx.success();
-        }
-        catch (Exception e) {
+        } catch (Exception e) {
             tx.failure();
             throw new IndexingException("Couldn't count: " + ontologyName, e);
-        }
-        finally {
+        } finally {
             tx.close();
         }
         return count.intValue();
diff --git a/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/loader/NodeCreator.java b/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/loader/NodeCreator.java
index 463c56b5..4334d7e9 100644
--- a/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/loader/NodeCreator.java
+++ b/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/loader/NodeCreator.java
@@ -1,54 +1,47 @@
 package uk.ac.ebi.spot.ols.loader;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import org.neo4j.graphdb.Label;
 import org.neo4j.unsafe.batchinsert.BatchInserter;
 import org.semanticweb.owlapi.model.IRI;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.ObjectMapper;
-
+import uk.ac.ebi.spot.ols.neo4j.model.Neo4JNodePropertyNameConstants;
 import uk.ac.ebi.spot.ols.util.LocalizedStrings;
 import uk.ac.ebi.spot.ols.util.OBODefinitionCitation;
 import uk.ac.ebi.spot.ols.util.OBOSynonym;
 import uk.ac.ebi.spot.ols.util.OBOXref;
 
-import static uk.ac.ebi.spot.ols.loader.Neo4JIndexerConstants.*;
+import java.util.*;
+
 import static uk.ac.ebi.spot.ols.config.OntologyDefaults.*;
+import static uk.ac.ebi.spot.ols.loader.Neo4JIndexerConstants.*;
 import static uk.ac.ebi.spot.ols.neo4j.model.Neo4JNodePropertyNameConstants.*;
-import uk.ac.ebi.spot.ols.neo4j.model.Neo4JNodePropertyNameConstants;
 
 /**
- * 
  * @author Henriette Harmse
  * @date 2019-05-10
- *
- * Samples, Phenotypes and Ontologies Team 
+ * <p>
+ * Samples, Phenotypes and Ontologies Team
  * EMBL-EBI
  */
 class NodeCreator {
-	
-	protected static Logger logger = LoggerFactory.getLogger(NodeCreator.class);
-	
-	protected NodeCreator() {
-	}
-
-    static Long getOrCreateNode(BatchInserter inserter, Map<String, Long> nodeMap, 
-    		OntologyLoader loader, IRI classIri, Collection<Label> nodeLabels) {
-    	
+
+    protected static Logger logger = LoggerFactory.getLogger(NodeCreator.class);
+
+    protected NodeCreator() {
+    }
+
+    static Long getOrCreateNode(BatchInserter inserter, Map<String, Long> nodeMap,
+                                OntologyLoader loader, IRI classIri, Collection<Label> nodeLabels) {
+
         if (!nodeMap.containsKey(classIri.toString())) {
             Map<String, Object> nodeProperties = new HashMap<>();
-            
+
             nodeProperties.put(OLS_ID, generateOlsId(loader.getOntologyName(), classIri));
             nodeProperties.put(Neo4JNodePropertyNameConstants.IRI, classIri.toString());
-            
+
             if (!addPropertiesForTopLevelTerms(classIri, nodeProperties)) {
                 addAppropriateLabelProperty(loader, classIri, nodeProperties);
             }
@@ -61,9 +54,9 @@ static Long getOrCreateNode(BatchInserter inserter, Map<String, Long> nodeMap,
 
             addAppropriateHasChildrenProperty(loader, classIri, nodeLabels, nodeProperties);
 
-            addAppropriateIsRootProperty(loader, classIri, nodeProperties);          
+            addAppropriateIsRootProperty(loader, classIri, nodeProperties);
             addPreferredRootPropertyConditionally(loader, classIri, nodeLabels, nodeProperties);
-            
+
             addShortFormPropertyConditionally(loader, classIri, nodeProperties);
             addOboIdPropertyConditionally(loader, classIri, nodeProperties);
             addSynonymsPropertyConditionally(loader, classIri, nodeProperties);
@@ -71,307 +64,310 @@ static Long getOrCreateNode(BatchInserter inserter, Map<String, Long> nodeMap,
             addDescriptionPropertyConditionally(loader, classIri, nodeProperties);
             addSuperClassDescriptionPropertyConditionally(loader, classIri, nodeProperties);
             addEquivalentClassDescriptionPropertyConditionally(loader, classIri, nodeProperties);
+            addAnonymousTypeDescriptionPropertyConditionally(loader, classIri, nodeProperties);
             addAnnotationPropertiesConditionally(loader, classIri, nodeProperties);
             addTermReplacedByPropertyConditionally(loader, classIri, nodeProperties);
             addOboRelatedPropertiesConditionally(loader, classIri, nodeProperties);
             addObsoleteLabelConditionally(loader, classIri, nodeLabels);
-            
-        	Label labelArray[] = nodeLabels.toArray(new Label[nodeLabels.size()]);
-        	logger.debug("classIri = " + classIri);
-        	logger.debug("nodeLabels = " + nodeLabels);
-        	logger.debug("inserter = " + inserter);
-
-			long classNode = 0;
-        	try {
-				classNode = inserter.createNode(nodeProperties, labelArray);
-			} catch (Throwable t) {
-        		logger.error(t.getMessage(), t);
-			}
+
+            Label labelArray[] = nodeLabels.toArray(new Label[nodeLabels.size()]);
+            logger.debug("classIri = " + classIri);
+            logger.debug("nodeLabels = " + nodeLabels);
+            logger.debug("inserter = " + inserter);
+
+            long classNode = 0;
+            try {
+                classNode = inserter.createNode(nodeProperties, labelArray);
+            } catch (Throwable t) {
+                logger.error(t.getMessage(), t);
+            }
 
             nodeMap.put(classIri.toString(), classNode);
         }
         return nodeMap.get(classIri.toString());
     }
 
-	protected static void addPreferredRootPropertyConditionally(OntologyLoader loader, IRI classIri,
-			Collection<Label> nodeLabels, Map<String, Object> nodeProperties) {
-		if (loader.getPreferredRootTerms().contains(classIri)) {
-			nodeProperties.put("is_preferred_root", loader.getPreferredRootTerms().contains(classIri));
-			logger.debug("About to add preferredRootTermLabel");
-			nodeLabels.add(preferredRootTermLabel);
-		}
-	}
-
-	protected static Collection<Label> addObsoleteLabelConditionally(OntologyLoader loader, IRI classIri,
-			Collection<Label> nodeLabels) {
-		if (loader.isObsoleteTerm(classIri)) {
-			logger.debug("About to add obsolete label");
-			nodeLabels.add(obsoleteLabel);
-		}
-		return nodeLabels;
-	}
-
-	protected static void addOboRelatedPropertiesConditionally(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-		ObjectMapper mapper = new ObjectMapper();            
-		addOboDefinitionCitationPropertyConditionally(mapper, loader, classIri, nodeProperties);
-		addOboSynonymsPropertyConditionally(mapper, loader, classIri, nodeProperties);
-		addOboXRefsConditionally(mapper, loader, classIri, nodeProperties);
-	}
-
-	protected static void addOboXRefsConditionally(ObjectMapper mapper, OntologyLoader loader, 
-			IRI classIri, Map<String, Object> nodeProperties) {
-		Collection<OBOXref> xrefs = loader.getOBOXrefs(classIri);
-		if (!xrefs.isEmpty()) {
-		    List<String> refs = new ArrayList<>();
-		    for (OBOXref xref : xrefs) {
-		        try {
-		            refs.add(mapper.writeValueAsString(xref));
-		        } catch (JsonProcessingException e) {
-		        }
-		    }
-		    nodeProperties.put(OBO_XREF, refs.toArray(new String [refs.size()]));
-		}
-	}
-
-	protected static void addOboSynonymsPropertyConditionally(ObjectMapper mapper, OntologyLoader loader,
-			IRI classIri, Map<String, Object> nodeProperties) {
-		
-		Collection<OBOSynonym> oboSynonyms = loader.getOBOSynonyms(classIri);
-		if (!oboSynonyms.isEmpty()) {
-		    List<String> syns = new ArrayList<>();
-		    for (OBOSynonym synonym : oboSynonyms) {
-		        try {
-		            syns.add(mapper.writeValueAsString(synonym));
-		        } catch (JsonProcessingException e) {
-		        }
-		    }
-		    nodeProperties.put(OBO_SYNONYM, syns.toArray(new String [syns.size()]));
-		}
-	}
-
-	protected static void addOboDefinitionCitationPropertyConditionally(ObjectMapper mapper, 
-			OntologyLoader loader, IRI classIri, Map<String, Object> nodeProperties) {
-		
-		Collection<OBODefinitionCitation> definitionCitations = loader.getOBODefinitionCitations(classIri);
-		if (!definitionCitations.isEmpty()) {
-		    List<String> mappedToStringDefinitionCitations = new ArrayList<>();
-		    for (OBODefinitionCitation citation : definitionCitations) {
-		        try {
-		            mappedToStringDefinitionCitations.add(mapper.writeValueAsString(citation));
-		        } catch (JsonProcessingException e) {
-		        	logger.debug("Citation '" + citation + "' could not be mapped to String.");
-		        }
-		    }
-		    nodeProperties.put(OBO_DEFINITION_CITATION,  mappedToStringDefinitionCitations.toArray(
-		    		new String [mappedToStringDefinitionCitations.size()]));
-		}
-	}
-
-
-	protected static void addTermReplacedByPropertyConditionally(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-		if (loader.getTermReplacedBy(classIri) != null) {
-		    nodeProperties.put(TERM_REPLACED_BY, loader.getTermReplacedBy(classIri).toString());
-		}
-	}
-
-
-	protected static void addAnnotationPropertiesConditionally(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-		Map<IRI, LocalizedStrings> annotations = loader.getAnnotations(classIri);
-		if (!annotations.isEmpty()) {
-		    for (IRI property : annotations.keySet()) {
-		        LocalizedStrings annotationLabels = loader.getTermLabels().get(property);
-		        LocalizedStrings annotationValues = annotations.get(property);
-				List<String> defaultValues = annotationValues.getStrings("en", "en-US");
-				if(defaultValues != null) {
-					String label = annotationLabels.getFirstString("en", "en-US");
-					String[] values = defaultValues.toArray(new String[0]);
-					nodeProperties.put(ANNOTATION_DESIGNATION + label, values);
-				}
-				for (String language : annotationLabels.getLanguages()) {
-					if(language.equals("")) {
-						continue;
-					}
-					List<String> localizedValues = annotationValues.getStrings(language);
-					if(localizedValues == null || localizedValues.size() == 0) {
-						localizedValues = annotationValues.getStrings("en", "en-US");
-					}
-					if (localizedValues != null) {
-						String label = annotationLabels.getFirstString(language);
-						String[] values = localizedValues.toArray(new String[0]);
-						nodeProperties.put(LOCALIZED_ANNOTATION_DESIGNATION + language
-								+ "-" + label, values);
-					}
-				}
-		    }
-		}
-	}
-
-	protected static void addEquivalentClassDescriptionPropertyConditionally(OntologyLoader loader, 
-			IRI classIri, Map<String, Object> nodeProperties) {
-		if (loader.getLogicalEquivalentClassDescriptions().containsKey(classIri)) {
-		    String [] descriptions = loader.getLogicalEquivalentClassDescriptions()
-		    		.get(classIri).toArray(new String 
-		    				[loader.getLogicalEquivalentClassDescriptions().get(classIri).size()]);
-		    nodeProperties.put(EQUIVALENT_CLASS_DESCRIPTION, descriptions);
-		}
-	}
-
-
-	protected static void addSuperClassDescriptionPropertyConditionally(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-		if (loader.getLogicalSuperClassDescriptions().containsKey(classIri)) {
-		    String [] descriptions = loader.getLogicalSuperClassDescriptions().get(classIri)
-		    		.toArray(new String [loader.getLogicalSuperClassDescriptions().get(classIri).size()]);
-		    nodeProperties.put(SUPER_CLASS_DESCRIPTION, descriptions);
-		}
-	}
-
-	protected static void addDescriptionPropertyConditionally(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-		if (loader.getTermDefinitions().containsKey(classIri)) {
-			LocalizedStrings definitions = loader.getTermDefinitions().get(classIri);
-
-			nodeProperties.put(DESCRIPTION, definitions.getStrings("en").toArray(new String[0]));
-
-			for (String language : definitions.getNonEnLanguages()) {
-				Collection<String> values = definitions.getStrings(language);
-				nodeProperties.put(LOCALIZED_DESCRIPTIONS + "-" + language, values.toArray(new String[0]));
-			}
-		}
-	}
-
-	protected static void addSubsetsPropertyConditionally(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-		if (!loader.getSubsets(classIri).isEmpty()) {
-		    String [] subsets = loader.getSubsets(classIri).toArray(
-		    		new String [loader.getSubsets(classIri).size()]);
-		    nodeProperties.put(IN_SUBSET, subsets);
-		}
-	}
-
-	protected static void addSynonymsPropertyConditionally(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-		if (loader.getTermSynonyms().containsKey(classIri)) {
-			LocalizedStrings synonyms = loader.getTermSynonyms().get(classIri);
-
-			nodeProperties.put(SYNONYM, synonyms.getStrings("en").toArray(new String[0]));
-
-			for (String language : synonyms.getNonEnLanguages()) {
-				String[] values = synonyms.getStrings(language).toArray(new String[0]);
-				nodeProperties.put(LOCALIZED_SYNONYMS + "-" + language, values);
-			}
-		}
-	}
-
-	protected static void addOboIdPropertyConditionally(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-		if (loader.getOboId(classIri) != null) {
-		    nodeProperties.put(OBO_ID, loader.getOboId(classIri));
-		}
-	}
-
-	protected static void addShortFormPropertyConditionally(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-		if (loader.getShortForm(classIri) != null) {
-		    nodeProperties.put(SHORT_FORM, loader.getShortForm(classIri));
-		}
-	}
-
-
-	protected static void addAppropriateIsRootProperty(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-		
-		nodeProperties.put(IS_ROOT, 
-				loader.getDirectParentTerms(classIri).isEmpty() && 
-					loader.getRelatedParentTerms(classIri).isEmpty());
-	}
+    protected static void addPreferredRootPropertyConditionally(OntologyLoader loader, IRI classIri,
+                                                                Collection<Label> nodeLabels, Map<String, Object> nodeProperties) {
+        if (loader.getPreferredRootTerms().contains(classIri)) {
+            nodeProperties.put("is_preferred_root", loader.getPreferredRootTerms().contains(classIri));
+            logger.debug("About to add preferredRootTermLabel");
+            nodeLabels.add(preferredRootTermLabel);
+        }
+    }
+
+    protected static Collection<Label> addObsoleteLabelConditionally(OntologyLoader loader, IRI classIri,
+                                                                     Collection<Label> nodeLabels) {
+        if (loader.isObsoleteTerm(classIri)) {
+            logger.debug("About to add obsolete label");
+            nodeLabels.add(obsoleteLabel);
+        }
+        return nodeLabels;
+    }
+
+    protected static void addOboRelatedPropertiesConditionally(OntologyLoader loader, IRI classIri,
+                                                               Map<String, Object> nodeProperties) {
+        ObjectMapper mapper = new ObjectMapper();
+        addOboDefinitionCitationPropertyConditionally(mapper, loader, classIri, nodeProperties);
+        addOboSynonymsPropertyConditionally(mapper, loader, classIri, nodeProperties);
+        addOboXRefsConditionally(mapper, loader, classIri, nodeProperties);
+    }
+
+    protected static void addOboXRefsConditionally(ObjectMapper mapper, OntologyLoader loader,
+                                                   IRI classIri, Map<String, Object> nodeProperties) {
+        Collection<OBOXref> xrefs = loader.getOBOXrefs(classIri);
+        if (!xrefs.isEmpty()) {
+            List<String> refs = new ArrayList<>();
+            for (OBOXref xref : xrefs) {
+                try {
+                    refs.add(mapper.writeValueAsString(xref));
+                } catch (JsonProcessingException e) {
+                }
+            }
+            nodeProperties.put(OBO_XREF, refs.toArray(new String[refs.size()]));
+        }
+    }
+
+    protected static void addOboSynonymsPropertyConditionally(ObjectMapper mapper, OntologyLoader loader,
+                                                              IRI classIri, Map<String, Object> nodeProperties) {
+
+        Collection<OBOSynonym> oboSynonyms = loader.getOBOSynonyms(classIri);
+        if (!oboSynonyms.isEmpty()) {
+            List<String> syns = new ArrayList<>();
+            for (OBOSynonym synonym : oboSynonyms) {
+                try {
+                    syns.add(mapper.writeValueAsString(synonym));
+                } catch (JsonProcessingException e) {
+                }
+            }
+            nodeProperties.put(OBO_SYNONYM, syns.toArray(new String[syns.size()]));
+        }
+    }
+
+    protected static void addOboDefinitionCitationPropertyConditionally(ObjectMapper mapper,
+                                                                        OntologyLoader loader, IRI classIri, Map<String, Object> nodeProperties) {
+
+        Collection<OBODefinitionCitation> definitionCitations = loader.getOBODefinitionCitations(classIri);
+        if (!definitionCitations.isEmpty()) {
+            List<String> mappedToStringDefinitionCitations = new ArrayList<>();
+            for (OBODefinitionCitation citation : definitionCitations) {
+                try {
+                    mappedToStringDefinitionCitations.add(mapper.writeValueAsString(citation));
+                } catch (JsonProcessingException e) {
+                    logger.debug("Citation '" + citation + "' could not be mapped to String.");
+                }
+            }
+            nodeProperties.put(OBO_DEFINITION_CITATION, mappedToStringDefinitionCitations.toArray(
+                    new String[mappedToStringDefinitionCitations.size()]));
+        }
+    }
+
+
+    protected static void addTermReplacedByPropertyConditionally(OntologyLoader loader, IRI classIri,
+                                                                 Map<String, Object> nodeProperties) {
+        if (loader.getTermReplacedBy(classIri) != null) {
+            nodeProperties.put(TERM_REPLACED_BY, loader.getTermReplacedBy(classIri).toString());
+        }
+    }
+
+
+    protected static void addAnnotationPropertiesConditionally(OntologyLoader loader, IRI classIri,
+                                                               Map<String, Object> nodeProperties) {
+        Map<IRI, LocalizedStrings> annotations = loader.getAnnotations(classIri);
+        if (!annotations.isEmpty()) {
+            for (IRI property : annotations.keySet()) {
+                LocalizedStrings annotationLabels = loader.getTermLabels().get(property);
+                LocalizedStrings annotationValues = annotations.get(property);
+                List<String> enValues = annotationValues.getStrings("en");
+                if (enValues != null) {
+                    String label = annotationLabels.getFirstString("en");
+                    String[] values = enValues.toArray(new String[0]);
+                    nodeProperties.put(ANNOTATION_DESIGNATION + label, values);
+                }
+                for (String language : annotationLabels.getNonEnLanguages()) {
+                    List<String> localizedValues = annotationValues.getStrings(language);
+                    if (localizedValues == null || localizedValues.size() == 0) {
+                        localizedValues = annotationValues.getStrings("en");
+                    }
+                    if (localizedValues != null) {
+                        String label = annotationLabels.getFirstString(language);
+                        String[] values = localizedValues.toArray(new String[0]);
+                        nodeProperties.put(LOCALIZED_ANNOTATION_DESIGNATION + language
+                                + "-" + label, values);
+                    }
+                }
+            }
+        }
+    }
+
+    protected static void addEquivalentClassDescriptionPropertyConditionally(OntologyLoader loader,
+                                                                             IRI classIri, Map<String, Object> nodeProperties) {
+        if (loader.getLogicalEquivalentClassDescriptions().containsKey(classIri)) {
+            String[] descriptions = loader.getLogicalEquivalentClassDescriptions()
+                    .get(classIri).toArray(new String
+                            [loader.getLogicalEquivalentClassDescriptions().get(classIri).size()]);
+            nodeProperties.put(EQUIVALENT_CLASS_DESCRIPTION, descriptions);
+        }
+    }
+
+    protected static void addSuperClassDescriptionPropertyConditionally(OntologyLoader loader, IRI classIri,
+                                                                        Map<String, Object> nodeProperties) {
+        if (loader.getLogicalSuperClassDescriptions().containsKey(classIri)) {
+            String[] descriptions = loader.getLogicalSuperClassDescriptions().get(classIri)
+                    .toArray(new String[loader.getLogicalSuperClassDescriptions().get(classIri).size()]);
+            nodeProperties.put(SUPER_CLASS_DESCRIPTION, descriptions);
+        }
+    }
+
+    protected static void addAnonymousTypeDescriptionPropertyConditionally(OntologyLoader loader, IRI classIri,
+                                                                           Map<String, Object> nodeProperties) {
+        if (loader.getAnonymousTypes().containsKey(classIri)) {
+            String[] descriptions = loader.getAnonymousTypes().get(classIri)
+                    .toArray(new String[loader.getAnonymousTypes().get(classIri).size()]);
+            nodeProperties.put(ANONYMOUS_TYPE, descriptions);
+        }
+    }
+
+    protected static void addDescriptionPropertyConditionally(OntologyLoader loader, IRI classIri,
+                                                              Map<String, Object> nodeProperties) {
+        if (loader.getTermDefinitions().containsKey(classIri)) {
+            LocalizedStrings definitions = loader.getTermDefinitions().get(classIri);
+
+            nodeProperties.put(DESCRIPTION, definitions.getStrings("en").toArray(new String[0]));
+
+            for (String language : definitions.getNonEnLanguages()) {
+                Collection<String> values = definitions.getStrings(language);
+                nodeProperties.put(LOCALIZED_DESCRIPTIONS + "-" + language, values.toArray(new String[0]));
+            }
+        }
+    }
+
+    protected static void addSubsetsPropertyConditionally(OntologyLoader loader, IRI classIri,
+                                                          Map<String, Object> nodeProperties) {
+        if (!loader.getSubsets(classIri).isEmpty()) {
+            String[] subsets = loader.getSubsets(classIri).toArray(
+                    new String[loader.getSubsets(classIri).size()]);
+            nodeProperties.put(IN_SUBSET, subsets);
+        }
+    }
+
+    protected static void addSynonymsPropertyConditionally(OntologyLoader loader, IRI classIri,
+                                                           Map<String, Object> nodeProperties) {
+        if (loader.getTermSynonyms().containsKey(classIri)) {
+            LocalizedStrings synonyms = loader.getTermSynonyms().get(classIri);
+
+            nodeProperties.put(SYNONYM, synonyms.getStrings("en").toArray(new String[0]));
+
+            for (String language : synonyms.getNonEnLanguages()) {
+                String[] values = synonyms.getStrings(language).toArray(new String[0]);
+                nodeProperties.put(LOCALIZED_SYNONYMS + "-" + language, values);
+            }
+        }
+    }
+
+    protected static void addOboIdPropertyConditionally(OntologyLoader loader, IRI classIri,
+                                                        Map<String, Object> nodeProperties) {
+        if (loader.getOboId(classIri) != null) {
+            nodeProperties.put(OBO_ID, loader.getOboId(classIri));
+        }
+    }
+
+    protected static void addShortFormPropertyConditionally(OntologyLoader loader, IRI classIri,
+                                                            Map<String, Object> nodeProperties) {
+        if (loader.getShortForm(classIri) != null) {
+            nodeProperties.put(SHORT_FORM, loader.getShortForm(classIri));
+        }
+    }
+
+
+    protected static void addAppropriateIsRootProperty(OntologyLoader loader, IRI classIri,
+                                                       Map<String, Object> nodeProperties) {
+
+        nodeProperties.put(IS_ROOT,
+                loader.getDirectParentTerms(classIri).isEmpty() &&
+                        loader.getRelatedParentTerms(classIri).isEmpty());
+    }
 
 
     /**
-     * Sets {@link Neo4JNodePropertyNameConstants#HAS_CHILDREN} property to true for terms that has 
-     * direct children or terms that are considered to be child-like relations (e.g. part-of, 
-     * develops-from etc.). For terms that are labelled as instances 
+     * Sets {@link Neo4JNodePropertyNameConstants#HAS_CHILDREN} property to true for terms that has
+     * direct children or terms that are considered to be child-like relations (e.g. part-of,
+     * develops-from etc.). For terms that are labelled as instances
      * {@link Neo4JNodePropertyNameConstants#HAS_CHILDREN} is set to false.
-     * 
+     *
      * @param loader
      * @param classIri
      * @param nodeLabels
      * @param nodeProperties
      */
-	protected static void addAppropriateHasChildrenProperty(OntologyLoader loader, IRI classIri,
-			Collection<Label> nodeLabels, Map<String, Object> nodeProperties) {
-		if (nodeLabels.contains(instanceLabel)) {
-		    nodeProperties.put(HAS_CHILDREN, false );
-		}
-		else  {
-		    nodeProperties.put(HAS_CHILDREN, (!loader.getDirectChildTerms(classIri).isEmpty() || 
-		    		!loader.getRelatedChildTerms(classIri).isEmpty()) );
-		}
-	}
+    protected static void addAppropriateHasChildrenProperty(OntologyLoader loader, IRI classIri,
+                                                            Collection<Label> nodeLabels, Map<String, Object> nodeProperties) {
+        if (nodeLabels.contains(instanceLabel)) {
+            nodeProperties.put(HAS_CHILDREN, false);
+        } else {
+            nodeProperties.put(HAS_CHILDREN, (!loader.getDirectChildTerms(classIri).isEmpty() ||
+                    !loader.getRelatedChildTerms(classIri).isEmpty()));
+        }
+    }
 
     /**
-     * Adds a {@link Neo4JNodePropertyNameConstants#LABEL} property for the node. Ontology designers 
-     * can define custom terms that they use for labelling their terms. This method only uses the 
+     * Adds a {@link Neo4JNodePropertyNameConstants#LABEL} property for the node. Ontology designers
+     * can define custom terms that they use for labelling their terms. This method only uses the
      * short form of classIri if no custom label terms have been defined for this classIri.
-     * 
+     *
      * @param loader
      * @param classIri
      * @param nodeProperties
      */
-	protected static void addAppropriateLabelProperty(OntologyLoader loader, IRI classIri,
-			Map<String, Object> nodeProperties) {
-
-		LocalizedStrings labels = loader.getTermLabels().get(classIri);
-
-		for (String lang : labels.getNonEnLanguages()) {
-			nodeProperties.put(Neo4JNodePropertyNameConstants.LOCALIZED_LABELS + "-" + lang,
-					labels.getStrings(lang).toArray(new String[0]));
-		}
-
-		if(labels.getFirstString("en") != null) {
-			nodeProperties.put(Neo4JNodePropertyNameConstants.LABEL,
-					labels.getFirstString("en"));
-		} else {
-			nodeProperties.put(Neo4JNodePropertyNameConstants.LABEL,
-					loader.getShortForm(classIri));
-		}
-
-	}
-
-	protected static String generateOlsId(String ontologyName, IRI classIri) {
-		return ontologyName.toLowerCase() + ":" + classIri.toString();
-	}
-	
-	/**
-	 * Deals with the top level OWL class or OWL object property. Note that OWL data properties are 
-	 * not considered.
-	 * 
-	 * @param classIri
-	 * @param nodeProperties
-	 * @return true if classIri represents a top-level OWL class or OWL object property, else false.
-	 *  
-	 */
-	protected static boolean addPropertiesForTopLevelTerms(IRI classIri, 
-			Map<String, Object> nodeProperties) {
-		
-		boolean isTopLevelTerm = false;
-		
+    protected static void addAppropriateLabelProperty(OntologyLoader loader, IRI classIri,
+                                                      Map<String, Object> nodeProperties) {
+
+        LocalizedStrings labels = loader.getTermLabels().get(classIri);
+
+        for (String lang : labels.getNonEnLanguages()) {
+            nodeProperties.put(Neo4JNodePropertyNameConstants.LOCALIZED_LABELS + "-" + lang,
+                    labels.getStrings(lang).toArray(new String[0]));
+        }
+
+        if (labels.getFirstString("en") != null) {
+            nodeProperties.put(Neo4JNodePropertyNameConstants.LABEL,
+                    labels.getFirstString("en"));
+        } else {
+            nodeProperties.put(Neo4JNodePropertyNameConstants.LABEL,
+                    loader.getShortForm(classIri));
+        }
+
+    }
+
+    protected static String generateOlsId(String ontologyName, IRI classIri) {
+        return ontologyName.toLowerCase() + ":" + classIri.toString();
+    }
+
+    /**
+     * Deals with the top level OWL class or OWL object property. Note that OWL data properties are
+     * not considered.
+     *
+     * @param classIri
+     * @param nodeProperties
+     * @return true if classIri represents a top-level OWL class or OWL object property, else false.
+     */
+    protected static boolean addPropertiesForTopLevelTerms(IRI classIri,
+                                                           Map<String, Object> nodeProperties) {
+
+        boolean isTopLevelTerm = false;
+
         if (classIri.toString().equals(THING)) {
-        	isTopLevelTerm = true;
+            isTopLevelTerm = true;
             nodeProperties.put(Neo4JNodePropertyNameConstants.LABEL, SHORT_THING);
             nodeProperties.put(HAS_CHILDREN, isTopLevelTerm);
-            
-        }
-        else if (classIri.toString().equals(TOP_OBJECT_PROPERTY)) {
-        	isTopLevelTerm = true;
+
+        } else if (classIri.toString().equals(TOP_OBJECT_PROPERTY)) {
+            isTopLevelTerm = true;
             nodeProperties.put(Neo4JNodePropertyNameConstants.LABEL, SHORT_TOP_OBJECT_PROPERTY);
             nodeProperties.put(HAS_CHILDREN, isTopLevelTerm);
-        }		
+        }
         return isTopLevelTerm;
-	}
+    }
 
 //    static Long getOrCreateNodeDeprecated(BatchInserter inserter, Map<String, Long> nodeMap, 
 //    		OntologyLoader loader, IRI classIri, Collection<Label> nodeLabels) {
@@ -532,5 +528,5 @@ else if (classIri.toString().equals(TOP_OBJECT_PROPERTY)) {
 //        }
 //        return nodeMap.get(classIri.toString());
 //    }
-    
+
 }
diff --git a/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/neo4j/model/Individual.java b/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/neo4j/model/Individual.java
index 4de6ddff..f18a9047 100644
--- a/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/neo4j/model/Individual.java
+++ b/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/neo4j/model/Individual.java
@@ -30,18 +30,21 @@ public class Individual {
     @JsonIgnore
     private String olsId;
 
-    @GraphProperty(propertyName = "iri")
+    @GraphProperty(propertyName = IRI)
     private String iri;
 
-    @GraphProperty(propertyName = "label")
+    @GraphProperty(propertyName = LABEL)
     private String label;
 
-    @GraphProperty(propertyName = "synonym")
+    @GraphProperty(propertyName = SYNONYM)
     private Set<String> synonym;
 
-    @GraphProperty(propertyName = "description")
+    @GraphProperty(propertyName = DESCRIPTION)
     private Set<String> description;
 
+    @GraphProperty(propertyName = ANONYMOUS_TYPE)
+    private Set<String> anonymousType;
+
     @GraphProperty(propertyName = LOCALIZED_LABELS)
     @JsonProperty(value = LOCALIZED_LABELS)
     private DynamicProperties localizedLabels = new DynamicPropertiesContainer();
@@ -54,32 +57,32 @@ public class Individual {
     @JsonProperty(value = LOCALIZED_DESCRIPTIONS)
     private DynamicProperties localizedDescriptions = new DynamicPropertiesContainer();
 
-    @GraphProperty(propertyName = "ontology_name")
-    @JsonProperty(value = "ontology_name")
+    @GraphProperty(propertyName = ONTOLOGY_NAME)
+    @JsonProperty(value = ONTOLOGY_NAME)
     private String ontologyName;
 
-    @GraphProperty(propertyName = "ontology_prefix")
-    @JsonProperty(value = "ontology_prefix")
+    @GraphProperty(propertyName = ONTOLOGY_PREFIX)
+    @JsonProperty(value = ONTOLOGY_PREFIX)
     private String ontologyPrefix;
 
-    @GraphProperty(propertyName = "ontology_iri")
-    @JsonProperty(value = "ontology_iri")
+    @GraphProperty(propertyName = ONTOLOGY_IRI)
+    @JsonProperty(value = ONTOLOGY_IRI)
     private String ontologyIri;
 
-    @GraphProperty(propertyName = "is_obsolete")
-    @JsonProperty(value = "is_obsolete")
+    @GraphProperty(propertyName = IS_OBSOLETE)
+    @JsonProperty(value = IS_OBSOLETE)
     private boolean isObsolete;
 
-    @GraphProperty(propertyName = "is_defining_ontology")
-    @JsonProperty(value = "is_defining_ontology")
+    @GraphProperty(propertyName = IS_DEFINING_ONTOLOGY)
+    @JsonProperty(value = IS_DEFINING_ONTOLOGY)
     private boolean isLocal;
 
-    @GraphProperty(propertyName = "short_form")
-    @JsonProperty(value = "short_form")
+    @GraphProperty(propertyName = SHORT_FORM)
+    @JsonProperty(value = SHORT_FORM)
     private String shortForm;
 
-    @GraphProperty(propertyName = "obo_id")
-    @JsonProperty(value = "obo_id")
+    @GraphProperty(propertyName = OBO_ID)
+    @JsonProperty(value = OBO_ID)
     private String oboId;
 
     private DynamicProperties annotation = new DynamicPropertiesContainer();
@@ -163,6 +166,10 @@ public Set<String> getDescription() {
         return description;
     }
 
+    public Set<String> getAnonymousType() {
+        return anonymousType;
+    }
+
     @JsonProperty(value = "ontology_name")
     public String getOntologyName() {
         return ontologyName;
diff --git a/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/neo4j/model/Neo4JNodePropertyNameConstants.java b/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/neo4j/model/Neo4JNodePropertyNameConstants.java
index ed695077..7dfdcd48 100644
--- a/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/neo4j/model/Neo4JNodePropertyNameConstants.java
+++ b/ols-neo4j/src/main/java/uk/ac/ebi/spot/ols/neo4j/model/Neo4JNodePropertyNameConstants.java
@@ -28,6 +28,7 @@ public class Neo4JNodePropertyNameConstants {
 	
 	public final static String SUPER_CLASS_DESCRIPTION = "superClassDescription";
 	public final static String EQUIVALENT_CLASS_DESCRIPTION = "equivalentClassDescription";
+	public final static String ANONYMOUS_TYPE = "anonymousType";
 	public final static String ANNOTATION_DESIGNATION = "annotation-";
 	public final static String LOCALIZED_ANNOTATION_DESIGNATION = "localizedAnnotation-";
 }
diff --git a/ols-web/src/main/java/uk/ac/ebi/spot/ols/controller/ui/IndividualControllerUI.java b/ols-web/src/main/java/uk/ac/ebi/spot/ols/controller/ui/IndividualControllerUI.java
index 9e20eb68..86285496 100644
--- a/ols-web/src/main/java/uk/ac/ebi/spot/ols/controller/ui/IndividualControllerUI.java
+++ b/ols-web/src/main/java/uk/ac/ebi/spot/ols/controller/ui/IndividualControllerUI.java
@@ -41,7 +41,7 @@ public class IndividualControllerUI {
     @RequestMapping(path = "/{onto}/individuals", method = RequestMethod.GET)
     String getIndividuals(
             @PathVariable("onto") String ontologyId,
-            @RequestParam(value = "iri", required = false) String termIri,
+            @RequestParam(value = "iri", required = false) String individualIri,
             @RequestParam(value = "short_form", required = false) String shortForm,
             @RequestParam(value = "lang", required = false, defaultValue = "en") String lang,
             @RequestParam(value = "obo_id", required = false) String oboId,
@@ -50,46 +50,47 @@ String getIndividuals(
 
         ontologyId = ontologyId.toLowerCase();
 
-        Individual term = null;
+        Individual individual = null;
 
-	model.addAttribute("lang", lang);
+        model.addAttribute("lang", lang);
 
         OntologyDocument document = repositoryService.get(ontologyId);
-	model.addAttribute("ontologyLanguages", document.getConfig().getLanguages());
+        model.addAttribute("ontologyLanguages", document.getConfig().getLanguages());
 
-        if (termIri != null) {
-            term = ontologyIndividualService.findByOntologyAndIri(ontologyId, termIri);
+        if (individualIri != null) {
+            individual = ontologyIndividualService.findByOntologyAndIri(ontologyId, individualIri);
         } else if (shortForm != null) {
-            term = ontologyIndividualService.findByOntologyAndShortForm(ontologyId, shortForm);
+            individual = ontologyIndividualService.findByOntologyAndShortForm(ontologyId, shortForm);
         } else if (oboId != null) {
-            term = ontologyIndividualService.findByOntologyAndOboId(ontologyId, oboId);
+            individual = ontologyIndividualService.findByOntologyAndOboId(ontologyId, oboId);
         }
 
-        if (termIri == null & shortForm == null & oboId == null) {
+        if (individualIri == null & shortForm == null & oboId == null) {
 
             if (pageable.getSort() == null) {
                 pageable = new PageRequest(pageable.getPageNumber(), pageable.getPageSize(), new Sort(new Sort.Order(Sort.Direction.ASC, "n.label")));
             }
 
-            Page<Individual> termsPage = ontologyIndividualService.findAllByOntology(ontologyId, pageable);
+            Page<Individual> individualsPage = ontologyIndividualService.findAllByOntology(ontologyId, pageable);
 
             model.addAttribute("ontologyName", document.getOntologyId());
             model.addAttribute("ontologyTitle", document.getConfig().getLocalizedTitle(lang));
             model.addAttribute("ontologyPrefix", document.getConfig().getPreferredPrefix());
             model.addAttribute("pageable", pageable);
-            model.addAttribute("allindividuals", termsPage);
-            model.addAttribute("allindividualssize", termsPage.getTotalElements());
+            model.addAttribute("allindividuals", individualsPage);
+            model.addAttribute("allindividualssize", individualsPage.getTotalElements());
             customisationProperties.setCustomisationModelAttributes(model);
             return "allindividuals";
         }
 
 
-        if (term == null) {
+        if (individual == null) {
             throw new ResourceNotFoundException("Can't find any individual with that id");
         }
 
-        model.addAttribute("ontologyIndividual", term);
-        model.addAttribute("indvidualTypes", ontologyIndividualService.getDirectTypes(ontologyId, term.getIri(), new PageRequest(0, 10)));
+        model.addAttribute("ontologyIndividual", individual);
+        model.addAttribute("individualTypes", ontologyIndividualService.getDirectTypes(ontologyId, individual.getIri(), new PageRequest(0, 10)));
+        model.addAttribute("individualAnonymousTypes", individual.getAnonymousType());
 
         String title = repositoryService.get(ontologyId).getConfig().getLocalizedTitle(lang);
         model.addAttribute("ontologyName", title);
diff --git a/ols-web/src/main/resources/templates/individual.html b/ols-web/src/main/resources/templates/individual.html
index f5374cf0..3a937bf4 100644
--- a/ols-web/src/main/resources/templates/individual.html
+++ b/ols-web/src/main/resources/templates/individual.html
@@ -203,7 +203,6 @@ <h2 property="name" style="margin: 0;" th:text="${ontologyIndividual.getLabelByL
                     <h4>Instance information</h4>
                 </div>
                 <div class="panel-body">
-
                     <div th:each="annotations: ${ontologyIndividual.getAnnotationByLang(lang)}">
                         <b>
                             <a href="#"
@@ -223,14 +222,18 @@ <h4 class="panel-title">Instance relations</h4>
                 </div>
 
                 <div class="panel-body">
-                    <div th:if="${indvidualTypes != null}">
+                    <div th:if="${individualTypes != null || individualAnonymousTypes != null}">
                         <b>Types</b>
-                        <br/>
-                        <div th:each="type : ${indvidualTypes}">
-                            <a href="#" th:href="@{terms (iri=${type.getIri()})}"
-                               th:text="${type.getLabelByLang(lang)}">parent
-                                1</a>
-                        </div>
+                        <ul>
+                            <li th:each="type : ${individualTypes}">
+                                <a href="#" th:href="@{terms (iri=${type.getIri()})}"
+                                   th:text="${type.getLabelByLang(lang)}">parent
+                                    1</a>
+                            </li>
+                            <li th:each="anonymousType : ${individualAnonymousTypes}"
+                                th:utext="${anonymousType}">NCBI_9606
+                            </li>
+                        </ul>
                     </div>
                 </div>
             </div>
diff --git a/ols-web/src/main/resources/templates/term.html b/ols-web/src/main/resources/templates/term.html
index 66996252..5312c2ee 100644
--- a/ols-web/src/main/resources/templates/term.html
+++ b/ols-web/src/main/resources/templates/term.html
@@ -41,7 +41,7 @@
                     <img th:src="@{../../img/file_JSON.png}" src="../static/img/file_JSON.png" alt="JSON"
                          title="Get data as JSON"/>
                 </a>
-                <label for="lang">Language</label>
+                <!--<label for="lang">Language</label>-->
             </div>
             <nav aria-label="You are here:" role="navigation">
                 <ul class="breadcrumbs">
@@ -127,8 +127,6 @@ <h2 property="name" style="margin-bottom: 0;" th:text="${ontologyTerm.getLabelBy
                 <hr/>
                 <div th:if="${ontologyTerm.isObsolete()}">
                     <div class="obsolete">This term is obsolete</div>
-                    <br/>
-                    <br/>
 
                     <div th:if="${ontologyTerm.getAnnotation().containsKey('reason_for_obsolescence')}">
                         <b>Reason for obsolescence</b>
@@ -160,26 +158,22 @@ <h2 property="name" style="margin-bottom: 0;" th:text="${ontologyTerm.getLabelBy
                 </div>
 
                 <div property="description">
-
-                    <div th:each="definitionCitation : ${definitionCitations}">
-                        <p>
-                            <span th:text="${definitionCitation.getDefinition()}"></span>
-                            [
-                            <span th:each="oboXref : ${definitionCitation.getOboXrefs()}">
+                    <p th:each="definitionCitation : ${definitionCitations}">
+                        <span th:text="${definitionCitation.getDefinition()}"></span>
+                        [
+                        <span th:each="oboXref : ${definitionCitation.getOboXrefs()}">
                             <a th:if="${oboXref.getUrl() != null}" target="_blank" th:href="${oboXref.getUrl()}"
                                th:text="${oboXref.getUrl()}"></a>
                             <span th:if="${oboXref.getDatabase() != null and oboXref.getUrl() == null}"
-                                  th:text="${oboXref.getDatabase()}"></span><!--
-                            --><span
-                                    th:if="${oboXref.getId() != null and oboXref.getDatabase() != null and oboXref.getUrl() == null}">:</span><!--
-                            --><span th:if="${oboXref.getId() != null and oboXref.getUrl() == null}"
-                                     th:text="${oboXref.getId()}"></span>
+                                  th:text="${oboXref.getDatabase()}"></span>
+                            <span th:if="${oboXref.getId() != null and oboXref.getDatabase() != null and oboXref.getUrl() == null}">:</span>
+                            <span th:if="${oboXref.getId() != null and oboXref.getUrl() == null}"
+                                  th:text="${oboXref.getId()}"></span>
                             <span th:if="${oboXref.getDescription() != null}"
                                   th:text="'(' + ${oboXref.getDescription()} + ')'"></span>
                         </span>
-                            ]
-                        </p>
-                    </div>
+                        ]
+                    </p>
 
                     <p th:unless="${definitionCitations}"
                        th:each="description : ${ontologyTerm.getDescriptionsByLang(lang)}"
@@ -197,12 +191,12 @@ <h2 property="name" style="margin-bottom: 0;" th:text="${ontologyTerm.getLabelBy
                     </p>
                 </div>
 
-            <div th:if="${ontologyTerm.getSynonymsByLang(lang) != null &&  ontologyTerm.getSynonymsByLang(lang).length > 0}">
-                <p><b>Synonyms:</b>
-                    <span property="alternateName" class="label synonym"
-                          th:each="synonym : ${ontologyTerm.getSynonymsByLang(lang)}"
-                          th:text="${synonym}">NCBI_9606</span>
-                </p>
+                <div th:if="${ontologyTerm.getSynonymsByLang(lang) != null &&  ontologyTerm.getSynonymsByLang(lang).length > 0}">
+                    <b>Synonyms:</b>
+                    <p property="alternateName" class="label synonym"
+                       th:each="synonym : ${ontologyTerm.getSynonymsByLang(lang)}"
+                       th:text="${synonym}">NCBI_9606</p>
+                </div>
             </div>
         </div>
 
@@ -213,10 +207,12 @@ <h2 property="name" style="margin-bottom: 0;" th:text="${ontologyTerm.getLabelBy
                                                         data-tabs-target="tree-tab"
                                                         href="#tree-tab"
                                                         aria-selected="true"><i class="icon icon-functional"
-                                                                                data-icon="h"></i> Tree view</a></li>
+                                                                                data-icon="h"></i> Tree view</a>
+                    </li>
                     <li class="tabs-title"><a id="oxo-link"
                                               data-tabs-target="oxo-tab"
-                                              href="#oxo-tab"><i class="icon icon-functional" data-icon="0"></i> Term
+                                              href="#oxo-tab"><i class="icon icon-functional" data-icon="0"></i>
+                        Term
                         mappings</a></li>
                     <!--<li class="tabs-title"><a id="diachron-link"
                                               data-tabs-target="diachron-tab"
@@ -341,16 +337,16 @@ <h4>Term information</h4>
                                th:href="@{../../search(q='database_cross_reference', exact='true', type='property', ontology=${ontologyTerm.ontologyName})}"><b>database
                                 cross reference</b></a>
                             <ul>
-                                <li style="margin-left: 9px;" th:each="oboXref: ${xrefs}">
+                                <li th:each="oboXref: ${xrefs}">
                                     <a th:if="${oboXref.getUrl() != null}" target="_blank"
                                        th:href="${oboXref.getUrl()}">
                                         <span th:text="${oboXref.getDatabase() + ':' + oboXref.getId()}"></span>
                                         <span th:if="${oboXref.getDescription() != null}" th:inline="text">([[${oboXref.getDescription()}]])</span>
                                     </a>
                                     <span th:if="${oboXref.getUrl() == null}">
-                                   <span th:text="${oboXref.getDatabase() + ':' + oboXref.getId()}"></span>
-                                   <span th:if="${oboXref.getDescription() != null}" th:inline="text">([[${oboXref.getDescription()}]])</span>
-                                </span>
+                                           <span th:text="${oboXref.getDatabase() + ':' + oboXref.getId()}"></span>
+                                           <span th:if="${oboXref.getDescription() != null}" th:inline="text">([[${oboXref.getDescription()}]])</span>
+                                        </span>
                                 </li>
                             </ul>
                         </div>
@@ -372,19 +368,19 @@ <h4>Term information</h4>
                                         <span th:text="${synonym.getName()}"></span>
                                         <span th:if="${not #sets.isEmpty(synonym.getXrefs())}">[</span>
                                         <span th:each="oboXref: ${synonym.getXrefs()}">
-                                        <a th:if="${oboXref.getUrl() != null}" target="_blank"
-                                           th:href="${oboXref.getUrl()}" th:text="${oboXref.getUrl()}"></a>
-                                        <span th:if="${oboXref.getDatabase() != null and oboXref.getUrl() == null}"
-                                              th:text="${oboXref.getDatabase()}"></span><!--
-                                     --><span th:if="${oboXref.getId() != null and oboXref.getDatabase() != null and oboXref.getUrl() == null}">:</span><!--
-                                     --><span th:if="${oboXref.getId() != null and oboXref.getUrl() == null}"
-                                              th:text="${oboXref.getId()}"></span>
-                                        <span th:if="${oboXref.getDescription() != null}"
-                                              th:text="'(' + ${oboXref.getDescription()} + ')'"></span>
-                                    </span>
+                                                <a th:if="${oboXref.getUrl() != null}" target="_blank"
+                                                   th:href="${oboXref.getUrl()}" th:text="${oboXref.getUrl()}"></a>
+                                                <span th:if="${oboXref.getDatabase() != null and oboXref.getUrl() == null}"
+                                                      th:text="${oboXref.getDatabase()}"></span>
+                                                <span
+                                                        th:if="${oboXref.getId() != null and oboXref.getDatabase() != null and oboXref.getUrl() == null}">:</span>
+                                                <span th:if="${oboXref.getId() != null and oboXref.getUrl() == null}"
+                                                      th:text="${oboXref.getId()}"></span>
+                                                <span th:if="${oboXref.getDescription() != null}"
+                                                      th:text="'(' + ${oboXref.getDescription()} + ')'"></span>
+                                            </span>
                                         <span th:if="${not #sets.isEmpty(synonym.getXrefs())}">]</span>
                                     </div>
-                                    <br/>
                                 </div>
                             </div>
                         </div>
@@ -393,84 +389,88 @@ <h4>Term information</h4>
                             <div th:unless="${annotations.key} eq 'database_cross_reference'">
                                 <b><a href="#"
                                       th:href="@{../../search(q=${annotations.key},exact='true', type=property, ontology=${ontologyTerm.ontologyName})}"
-                                      th:text="${annotations.key.replaceAll('_', ' ')}">property name</a></b>
-                                <p th:inline="text">
-                                <div th:each="value: ${annotations.value}" th:inline="text">
-                                    <p class="annotation-value">[[${value}]]</p>
-                                </div>
-                                </p>
+                                      th:text="${annotations.key.replaceAll('_', ' ')}">property name
+                                </a></b>
+                                <ul>
+                                    <li th:each="value: ${annotations.value}"
+                                        th:inline="text"
+                                        class="annotation-value">[[${value}]]
+                                    </li>
+                                </ul>
                             </div>
                         </div>
                     </div>
-                </div>
 
-                <div id="term_relation_box" class="panel">
-                    <div class="panel-heading">
-                        <h4>Term relations</h4>
-                    </div>
+                    <div id="term_relation_box" class="panel">
+                        <div class="panel-heading">
+                            <h4>Term relations</h4>
+                        </div>
 
-                    <div class="panel-body">
-                        <!--div th:if="${parentTerms != null}">
-                            <b>Parents</b>
-                            <br/>
-                        </div-->
+                        <div class="panel-body">
+                            <!--div th:if="${parentTerms != null}">
+                                <b>Parents</b>
+                            </div-->
 
-                        <div th:if="${ontologyTerm.getEquivalentClassDescription() != null}">
-                            <b>Equivalent to: </b>
-                            <br/>
-                            <ul>
-                                <li th:each="equivclassDesc : ${ontologyTerm.getEquivalentClassDescription()}"
-                                    th:utext="${equivclassDesc}">NCBI_9606
-                                </li>
-                            </ul>
-                            <br/>
-                        </div>
+                            <div th:if="${ontologyTerm.getEquivalentClassDescription() != null}">
+                                <b>Equivalent to: </b>
+                                <ul>
+                                    <li th:each="equivclassDesc : ${ontologyTerm.getEquivalentClassDescription()}"
+                                        th:utext="${equivclassDesc}">NCBI_9606
+                                    </li>
+                                </ul>
+                            </div>
 
-                        <div>
-                            <b>Subclass of: </b>
-                            <br/>
-                            <ul>
-                                <li th:each="parentTerm : ${parentTerms}">
-                                    <a href="#" th:title="${parentTerm.getIri()}"
-                                       th:href="@{terms (iri=${parentTerm.getIri()})}"
-                                       th:text="${parentTerm.getLabelByLang(lang)}">parent 1</a></li>
-                                <li th:each="superclassDesc : ${ontologyTerm.getSuperClassDescription()}"
-                                    th:utext="${superclassDesc}">NCBI_9606
-                                </li>
-                            </ul>
-                            <br/>
-                        </div>
+                            <div th:if="${parentTerms != null}">
+                                <b>Subclass of: </b>
+                                <ul>
+                                    <li th:each="parentTerm : ${parentTerms}">
+                                        <a href="#" th:title="${parentTerm.getIri()}"
+                                           th:href="@{terms (iri=${parentTerm.getIri()})}"
+                                           th:text="${parentTerm.getLabelByLang(lang)}">parent 1</a></li>
+                                    <li th:each="superclassDesc : ${ontologyTerm.getSuperClassDescription()}"
+                                        th:utext="${superclassDesc}">NCBI_9606
+                                    </li>
+                                </ul>
+                            </div>
+
+                            <div th:if="${not #maps.isEmpty(relatedFroms)}">
+                                <b>Related from:</b>
+                                <div th:each="relation : ${relatedFroms}">
+                                    <a class="ObjectProperty"
+                                       th:href="@{../../search(q=${relation.key},exact='true', type=property, ontology=${ontologyTerm.ontologyName})}"
+                                       th:text="${relation.key}"></a>
+                                    <ul>
+                                        <li th:each="term,iterStat: ${relation.value}">
+                                            <!--<a href="#"
+                                               th:title="${term.iri}"
+                                               th:href="@{terms (iri=${term.iri})}"
+                                               th:text="${term.label}">parent 1
+                                            </a>-->
+                                            <a href="#"
+                                               th:title="${term.iri}"
+                                               th:href="@{../../search(q=${term.label},exact='true',ontology=${ontologyTerm.ontologyName})}"
+                                               th:text="${term.label}">parent 1
+                                            </a>
+                                        </li>
+                                    </ul>
+                                    <!--span th:each="term,iterStat: ${relation.value}">
+                                        <a href="#" th:href="@{terms (iri=${term.iri})}" th:text="${term.label}">parent 1</a>
+                                        <span th:if="${iterStat.count &lt; iterStat.size}">, </span>
+                                    </span-->
+                                </div>
+                            </div>
 
-                        <div th:if="${not #maps.isEmpty(relatedFroms)}">
-                            <b>Related from:</b>
-                            <br/>
-                            <div th:each="relation : ${relatedFroms}">
-                                <a class="ObjectProperty"
-                                   th:href="@{../../search(q=${relation.key},exact='true', type=property, ontology=${ontologyTerm.ontologyName})}"
-                                   th:text="${relation.key}"></a>
+                            <div th:if="${not #sets.isEmpty(instances)}">
+                                <b>Instances:</b>
                                 <ul>
-                                    <li th:each="term,iterStat: ${relation.value}"><a href="#"
-                                                                                      th:title="${term.iri}"
-                                                                                      th:href="@{terms (iri=${term.iri})}"
-                                                                                      th:text="${term.label}">parent
+                                    <li th:each="instance : ${instances}"><a href="#"
+                                                                             th:title="${instance.iri}"
+                                                                             th:href="@{individuals (iri=${instance.iri})}"
+                                                                             th:text="${instance.getLabelByLang(lang)}">parent
                                         1</a></li>
                                 </ul>
-                                <!--span th:each="term,iterStat: ${relation.value}">
-                                    <a href="#" th:href="@{terms (iri=${term.iri})}" th:text="${term.label}">parent 1</a>
-                                    <span th:if="${iterStat.count &lt; iterStat.size}">, </span>
-                                </span-->
                             </div>
                         </div>
-
-                        <div th:if="${not #sets.isEmpty(instances)}">
-                            <b>Instances:</b>
-                            <ul>
-                                <li th:each="instance : ${instances}"><a href="#"
-                                                                         th:title="${instance.iri}"
-                                                                         th:href="@{individuals (iri=${instance.iri})}"
-                                                                         th:text="${instance.getLabelByLang(lang)}">parent 1</a></li>
-                            </ul>
-                        </div>
                     </div>
                 </div>
             </div>
diff --git a/ontology-tools/src/main/java/uk/ac/ebi/spot/ols/loader/AbstractOWLOntologyLoader.java b/ontology-tools/src/main/java/uk/ac/ebi/spot/ols/loader/AbstractOWLOntologyLoader.java
index 8793014e..f556dc80 100644
--- a/ontology-tools/src/main/java/uk/ac/ebi/spot/ols/loader/AbstractOWLOntologyLoader.java
+++ b/ontology-tools/src/main/java/uk/ac/ebi/spot/ols/loader/AbstractOWLOntologyLoader.java
@@ -1,8 +1,6 @@
 package uk.ac.ebi.spot.ols.loader;
 
 import com.google.common.collect.Multimap;
-
-import org.mockito.internal.debugging.Localized;
 import org.semanticweb.owlapi.apibinding.OWLManager;
 import org.semanticweb.owlapi.io.OWLObjectRenderer;
 import org.semanticweb.owlapi.manchestersyntax.renderer.ManchesterOWLSyntaxOWLObjectRendererImpl;
@@ -43,12 +41,12 @@
  * @author Tony Burdett
  * @author Simon Jupp
  * @date 03/02/2015
- *
+ * <p>
  * This Abstract class provies an OWL API based implementation of an ontology loader. Ontologies are loaded
  * and various caches are created for extracting  common slices out of the ontology.
  * This class has being doing the rounds in various guises for a while now and had become a bit unwieldy
  * todo refactor do include individual processors for various aspects of the ontology we want to extract
- *
+ * <p>
  * Samples, Phenotypes and Ontologies Team, EMBL-EBI
  */
 public abstract class
@@ -60,8 +58,8 @@
     private IRI ontologyVersionIRI;
     private String ontologyName;
 
-    private Map<String,String> ontologyTitles;
-    private Map<String,String> ontologyDescriptions;
+    private Map<String, String> ontologyTitles;
+    private Map<String, String> ontologyDescriptions;
 
     private Set<String> ontologyLanguages = new HashSet<>();
 
@@ -76,21 +74,21 @@
     private Resource ontologyResource;
     private Map<IRI, IRI> ontologyImportMappings;
 
-    private Collection<IRI> classes  = new HashSet<IRI>();
-    private Collection<IRI> individuals  = new HashSet<IRI>();
-    private Collection<IRI> objectProperties  = new HashSet<IRI>();
-    private Collection<IRI> dataProperties  = new HashSet<IRI>();
-    private Collection<IRI> annotationProperties  = new HashSet<IRI>();
-    private Collection<IRI> owlVocabulary  = new HashSet<IRI>();
+    private Collection<IRI> classes = new HashSet<IRI>();
+    private Collection<IRI> individuals = new HashSet<IRI>();
+    private Collection<IRI> objectProperties = new HashSet<IRI>();
+    private Collection<IRI> dataProperties = new HashSet<IRI>();
+    private Collection<IRI> annotationProperties = new HashSet<IRI>();
+    private Collection<IRI> owlVocabulary = new HashSet<IRI>();
 
     private IRI labelIRI = Namespaces.RDFS.createIRI("label");
     private Collection<IRI> synonymIRIs = new HashSet<IRI>();
-    private Collection<IRI> definitionIRIs  = new HashSet<IRI>();
+    private Collection<IRI> definitionIRIs = new HashSet<IRI>();
 
     // Henriette To do: Remove
-    private Collection<IRI> hiddenIRIs  = new HashSet<IRI>();
+    private Collection<IRI> hiddenIRIs = new HashSet<IRI>();
 
-    private Collection<IRI> unsatisfiableIris  = new HashSet<IRI>();
+    private Collection<IRI> unsatisfiableIris = new HashSet<IRI>();
 
     private IRI exclusionClassIRI;
     private IRI exclusionAnnotationIRI;
@@ -98,7 +96,7 @@
     private OWLOntologyManager manager;
     private OWLDataFactory factory;
     private OWLOntology ontology;
-    
+
     private boolean OWLAPIInitialized = false;
 
     private Collection<String> baseIRIs = new HashSet<>();
@@ -108,7 +106,7 @@
     private Map<IRI, LocalizedStrings> ontologyLabels = new HashMap<>();
     private Map<IRI, LocalizedStrings> ontologySynonyms = new HashMap<>();
     private Map<IRI, LocalizedStrings> ontologyDefinitions = new HashMap<>();
-    private Map<IRI, Map<IRI,LocalizedStrings>> termAnnotations = new HashMap<>();
+    private Map<IRI, Map<IRI, LocalizedStrings>> termAnnotations = new HashMap<>();
     private Collection<IRI> obsoleteTerms = new HashSet<>();
     private Map<IRI, Collection<String>> slims = new HashMap<>();
     private Map<IRI, String> termReplacedBy = new HashMap<>();
@@ -144,7 +142,7 @@
      * A map of a map of the property IRIs and the class IRIs the property IRI are related to for
      * each term in the ontology.
      */
-    private Map<IRI, Map<IRI,Collection<IRI>>> relatedTerms = new HashMap<>();
+    private Map<IRI, Map<IRI, Collection<IRI>>> relatedTerms = new HashMap<>();
 
     /**
      * A map of the terms that can be considered to be related to a term via a "hierarchical
@@ -154,7 +152,7 @@
      * property IRI. This map is generated based on the IRIs stored in {@link #hierarchicalRels} and
      * the {@link #isPartOf(IRI)} method.
      */
-    private Map<IRI, Map<IRI,Collection<IRI>>> relatedParentTerms = new HashMap<>();
+    private Map<IRI, Map<IRI, Collection<IRI>>> relatedParentTerms = new HashMap<>();
 
     /**
      * This is a map of the terms that are subclasses of existential restrictions using via property
@@ -166,20 +164,20 @@
     private Map<IRI, Collection<IRI>> relatedChildTerms = new HashMap<>();
 
     // Henriette To do: Is this used?
-    private Map<IRI, Map<IRI,Collection<IRI>>> allRelatedTerms = new HashMap<>();
+    private Map<IRI, Map<IRI, Collection<IRI>>> allRelatedTerms = new HashMap<>();
     /**
      * A map of the individuals which have existential restrictions as type where the filler of the
      * existential restriction is a nominal. For each such individual a map is stored of the related
      * property IRI and its (n) filler(s).
      */
-    private Map<IRI, Map<IRI,Collection<IRI>>> allRelatedIndividuals = new HashMap<>();
-    private Map<IRI, Map<IRI,Collection<IRI>>> allRelatedIndividualsToClasses = new HashMap<>();
+    private Map<IRI, Map<IRI, Collection<IRI>>> allRelatedIndividuals = new HashMap<>();
+    private Map<IRI, Map<IRI, Collection<IRI>>> allRelatedIndividualsToClasses = new HashMap<>();
     /**
      * A map of the individuals which have existential restrictions as type where the filler of the
      * existential restriction is a class. For each such individual a map is stored of the related
      * property IRI and its (class) filler(s).
      */
-    private Map<IRI, Map<IRI,Collection<IRI>>> allRelatedClassesToIndividuals = new HashMap<>();
+    private Map<IRI, Map<IRI, Collection<IRI>>> allRelatedClassesToIndividuals = new HashMap<>();
     /**
      * Terms that have defined by the ontology designer as being preferred root terms for the
      * ontology.
@@ -199,6 +197,7 @@
 
     private Map<IRI, Collection<String>> equivalentClassExpressionsAsString = new HashMap<>();
     private Map<IRI, Collection<String>> superclassExpressionsAsString = new HashMap<>();
+    private Map<IRI, Collection<String>> anonymousTypeExpressionsAsString = new HashMap<>();
     private String preferredPrefix;
     private Map<OWLAnnotationProperty, List<String>> preferredLanguageMap = new HashMap<>();
 
@@ -213,23 +212,23 @@ public AbstractOWLOntologyLoader(OntologyResourceConfig config) throws OntologyL
     }
 
     public AbstractOWLOntologyLoader(OntologyResourceConfig config, DatabaseService databaseService,
-    		OntologyLoadingConfiguration ontologyLoadingConfiguration)
-    		throws OntologyLoadingException {
-    	
+                                     OntologyLoadingConfiguration ontologyLoadingConfiguration)
+            throws OntologyLoadingException {
+
         this.databaseService = databaseService;
         this.ontologyLoadingConfiguration = ontologyLoadingConfiguration;
-    	readConfiguration(config);
-    	initializeOWLAPIWithoutReasoner();
-    	initializeEnglishLanguagePreference();
-    	initializeVocabularyToIgnore();
+        readConfiguration(config);
+        initializeOWLAPIWithoutReasoner();
+        initializeEnglishLanguagePreference();
+        initializeVocabularyToIgnore();
     }
-    
+
     private void initializeEnglishLanguagePreference() throws OntologyLoadingException {
-    	if (!OWLAPIInitialized) {
-    		initializeOWLAPIWithoutReasoner();
-    	} 
-    	setPreferredLanguageMap(factory.getOWLAnnotationProperty(getLabelIRI()), 
-        		Arrays.asList("en", ""));
+        if (!OWLAPIInitialized) {
+            initializeOWLAPIWithoutReasoner();
+        }
+        setPreferredLanguageMap(factory.getOWLAnnotationProperty(getLabelIRI()),
+                Arrays.asList("en", ""));
     }
 
     private void readConfiguration(OntologyResourceConfig config) throws OntologyLoadingException {
@@ -249,7 +248,7 @@ private void readConfiguration(OntologyResourceConfig config) throws OntologyLoa
         setPreferredPrefix(config.getPreferredPrefix());
         setSynonymIRIs(config.getSynonymProperties().stream()
                 .map(IRI::create).
-                        collect(Collectors.toSet()));
+                collect(Collectors.toSet()));
 
         setHiddenIRIs(
                 config.getHiddenProperties()
@@ -271,20 +270,20 @@ private void readConfiguration(OntologyResourceConfig config) throws OntologyLoa
                 .map(IRI::create)
                 .collect(Collectors.toSet()));
 
-        
+
         try {
-			setOntologyResource(new UrlResource(config.getFileLocation()));
-		} catch (MalformedURLException e) {
-			throw new OntologyLoadingException("Can't load file from " + 
-					config.getFileLocation(), e);
-		}
+            setOntologyResource(new UrlResource(config.getFileLocation()));
+        } catch (MalformedURLException e) {
+            throw new OntologyLoadingException("Can't load file from " +
+                    config.getFileLocation(), e);
+        }
 
         setPreferredRootTerms(config.getPreferredRootTerms()
                 .stream()
                 .map(IRI::create)
                 .collect(Collectors.toSet()));
     }
-    
+
     private void initializeOWLAPIWithoutReasoner() throws OntologyLoadingException {
         this.manager = OWLManager.createOWLOntologyManager();
         OWLOntologyLoaderConfiguration config = new OWLOntologyLoaderConfiguration();
@@ -292,15 +291,15 @@ private void initializeOWLAPIWithoutReasoner() throws OntologyLoadingException {
         this.manager.setOntologyLoaderConfiguration(config);
 
         if (getOntologyResource() != null) {
-        	try {
-			getLogger().info("Mapping ontology IRI from " + getOntologyIRI() + " to " +
-					getOntologyResource().getURI());
-            this.manager.addIRIMapper(new SimpleIRIMapper(getOntologyIRI(),
-                    IRI.create(getOntologyResource().getURI())));
-        	} catch (IOException e) {
-        		throw new OntologyLoadingException("The ontology " + getOntologyIRI() + 
-        				" could not be loaded", e);
-        	}
+            try {
+                getLogger().info("Mapping ontology IRI from " + getOntologyIRI() + " to " +
+                        getOntologyResource().getURI());
+                this.manager.addIRIMapper(new SimpleIRIMapper(getOntologyIRI(),
+                        IRI.create(getOntologyResource().getURI())));
+            } catch (IOException e) {
+                throw new OntologyLoadingException("The ontology " + getOntologyIRI() +
+                        " could not be loaded", e);
+            }
         }
         if (getOntologyImportMappings() != null) {
             for (IRI from : getOntologyImportMappings().keySet()) {
@@ -313,16 +312,16 @@ private void initializeOWLAPIWithoutReasoner() throws OntologyLoadingException {
 
         OWLAPIInitialized = true;
     }
-    
+
     private void initializeVocabularyToIgnore() throws OntologyLoadingException {
-    	if (!OWLAPIInitialized) {
-    		initializeOWLAPIWithoutReasoner();
-    	} 
-    	
+        if (!OWLAPIInitialized) {
+            initializeOWLAPIWithoutReasoner();
+        }
+
         owlVocabulary.add(factory.getOWLThing().getIRI());
         owlVocabulary.add(factory.getOWLNothing().getIRI());
         owlVocabulary.add(factory.getOWLTopObjectProperty().getIRI());
-        owlVocabulary.add(factory.getOWLBottomObjectProperty().getIRI());    	
+        owlVocabulary.add(factory.getOWLBottomObjectProperty().getIRI());
     }
 
     @Override
@@ -331,39 +330,36 @@ public String getShortForm(IRI ontologyTermIRI) {
         if (getOntologyTermAccessions().containsKey(ontologyTermIRI)) {
             getOntologyTermAccessions().get(ontologyTermIRI);
         }
-        return  extractShortForm(ontologyTermIRI).get();
+        return extractShortForm(ontologyTermIRI).get();
     }
 
     @Override
     public String getOboId(IRI ontologyTermIRI) {
 
         if (getOntologyTermOboId().containsKey(ontologyTermIRI)) {
-            return  getOntologyTermOboId().get(ontologyTermIRI);
+            return getOntologyTermOboId().get(ontologyTermIRI);
         }
-        return  null;
+        return null;
     }
 
-    
-    
+
     private <G> G lazyGet(Callable<G> callable) {
-    	try {
+        try {
             initOrWait();
             return callable.call();
-        }
-        catch (InterruptedException e) {
+        } catch (InterruptedException e) {
             throw new IllegalStateException(getClass().getSimpleName() + " failed to initialize", e);
-        }
-        catch (Exception e) {
+        } catch (Exception e) {
             throw new RuntimeException("Failed to lazily instantiate collection for query", e);
         }
     }
 
-    @Override 
-    protected void doInitialization() throws Exception {        
+    @Override
+    protected void doInitialization() throws Exception {
         this.ontology = loadOntology();
     }
 
-    @Override 
+    @Override
     protected void doTermination() throws Exception {
         // nothing to do
     }
@@ -448,13 +444,11 @@ protected OWLOntology loadOntology() throws OWLOntologyCreationException {
                     ":After index annotations", ":");
 
             return ontology;
-        }
-        catch (Exception e) {
+        } catch (Exception e) {
             setInitializationException(e);
             getLogger().error("Failed to parse " + getOntologyName() + " : " + e.getMessage(), e);
             throw e;
-        }
-        finally {
+        } finally {
             setReady(true);
             discardReasoner(ontology);
         }
@@ -479,13 +473,13 @@ public static String parseOboVersion(IRI ontologyVersionIRI) {
     }
 
     private void indexOntologyAnnotations(Set<OWLAnnotation> owlAnnotations) {
-    	getLogger().debug("Calling indexOntologyAnnotations");
+        getLogger().debug("Calling indexOntologyAnnotations");
 
         Set<String> creators = new HashSet<>();
         Map<String, Map<String, List<String>>> annotations = new HashMap<>();
 
         Collection<IRI> preferredRootTermAnnotations = new HashSet<>();
-         for (OWLAnnotation annotation : owlAnnotations) {
+        for (OWLAnnotation annotation : owlAnnotations) {
 
             OWLAnnotationProperty annotationProperty = annotation.getProperty();
             OWLAnnotationValue annotationValue = annotation.getValue();
@@ -496,100 +490,91 @@ private void indexOntologyAnnotations(Set<OWLAnnotation> owlAnnotations) {
             getLogger().debug("annotationPropertyIri 1 = " + annotationPropertyIri);
             if (annotationPropertyIri.toString().equals(OntologyDefaults.DEFINITION)) {
                 if (theValue.isPresent()) {
-                    Map<String,String> descriptions = new HashMap<>();
+                    Map<String, String> descriptions = new HashMap<>();
                     descriptions.put("en", theValue.get());
                     setOntologyDescriptions(descriptions);
                     internalMetadataProperties.add(OntologyDefaults.DEFINITION);
                 }
-            }
-            else if (annotationPropertyIri.toString().equals(OntologyDefaults.TITLE)) {
+            } else if (annotationPropertyIri.toString().equals(OntologyDefaults.TITLE)) {
                 if (theValue.isPresent()) {
-                    Map<String,String> titles = new HashMap<>();
+                    Map<String, String> titles = new HashMap<>();
                     titles.put("en", theValue.get());
                     setOntologyTitles(titles);
                     internalMetadataProperties.add(OntologyDefaults.TITLE);
                 }
-            }
-            else if (annotationPropertyIri.toString().equals(OntologyDefaults.CREATOR)) {
+            } else if (annotationPropertyIri.toString().equals(OntologyDefaults.CREATOR)) {
                 if (theValue.isPresent()) {
                     creators.add(theValue.get());
                     internalMetadataProperties.add(OntologyDefaults.CREATOR);
                 }
-            }
-            else if (annotationPropertyIri.toString().equals(OntologyDefaults.MAILINGLIST)) {
-                if (annotationValue != null && annotationValue instanceof  IRI) {
-                    setOntologyHomePage( ((IRI) annotationValue).toString());
+            } else if (annotationPropertyIri.toString().equals(OntologyDefaults.MAILINGLIST)) {
+                if (annotationValue != null && annotationValue instanceof IRI) {
+                    setOntologyHomePage(((IRI) annotationValue).toString());
                     internalMetadataProperties.add(OntologyDefaults.MAILINGLIST);
                 } else if (theValue.isPresent()) {
                     setOntologyMailingList(theValue.get());
                     internalMetadataProperties.add(OntologyDefaults.MAILINGLIST);
                 }
-            }
-            else if (annotationPropertyIri.toString().equals(OntologyDefaults.TRACKER)) {
-                if (annotationValue != null && annotationValue instanceof  IRI) {
-                    setOntologyTracker( ((IRI) annotationValue).toString());
+            } else if (annotationPropertyIri.toString().equals(OntologyDefaults.TRACKER)) {
+                if (annotationValue != null && annotationValue instanceof IRI) {
+                    setOntologyTracker(((IRI) annotationValue).toString());
                     internalMetadataProperties.add(OntologyDefaults.TRACKER);
                 } else if (theValue.isPresent()) {
                     setOntologyTracker(theValue.get());
                     internalMetadataProperties.add(OntologyDefaults.TRACKER);
                 }
-            }
-            else if (annotationPropertyIri.toString().equals(OntologyDefaults.LOGO)) {
-                if (annotationValue != null && annotationValue instanceof  IRI) {
-                    setOntologyLogo( ((IRI) annotationValue).toString());
+            } else if (annotationPropertyIri.toString().equals(OntologyDefaults.LOGO)) {
+                if (annotationValue != null && annotationValue instanceof IRI) {
+                    setOntologyLogo(((IRI) annotationValue).toString());
                     internalMetadataProperties.add(OntologyDefaults.LOGO);
                 } else if (theValue.isPresent()) {
                     setOntologyLogo(theValue.get());
                     internalMetadataProperties.add(OntologyDefaults.LOGO);
                 }
-            }
-            else if (annotationPropertyIri.toString().equals(OntologyDefaults.HOMEPAGE)) {
-                if (annotationValue != null && annotationValue instanceof  IRI) {
-                    setOntologyHomePage( ((IRI) annotationValue).toString());
+            } else if (annotationPropertyIri.toString().equals(OntologyDefaults.HOMEPAGE)) {
+                if (annotationValue != null && annotationValue instanceof IRI) {
+                    setOntologyHomePage(((IRI) annotationValue).toString());
                     internalMetadataProperties.add(OntologyDefaults.HOMEPAGE);
-                }
-                else if (theValue.isPresent()) {
+                } else if (theValue.isPresent()) {
                     setOntologyHomePage(theValue.get());
                     internalMetadataProperties.add(OntologyDefaults.HOMEPAGE);
                 }
-            }
-            else if (annotationPropertyIri.toString().equals(OntologyDefaults.VERSION)) {
+            } else if (annotationPropertyIri.toString().equals(OntologyDefaults.VERSION)) {
                 if (theValue.isPresent()) {
                     setOntologyVersion(theValue.get());
                     internalMetadataProperties.add(OntologyDefaults.VERSION);
                 }
             } else if (annotationPropertyIri.toString().equals(
-            		ontologyLoadingConfiguration.getPreferredRootTermAnnotationProperty())) {
+                    ontologyLoadingConfiguration.getPreferredRootTermAnnotationProperty())) {
 
                 getLogger().debug("Check whether we can add preferredRootTerms for: "
-            		+ annotationPropertyIri);
+                        + annotationPropertyIri);
 
-            	if (annotationValue instanceof IRI) {
-                    preferredRootTermAnnotations.add((IRI)annotationValue);
-            	}
-            }
-            else  {
+                if (annotationValue instanceof IRI) {
+                    preferredRootTermAnnotations.add((IRI) annotationValue);
+                }
+            } else {
 
-		/// TODO: what about localized values?
+                /// TODO: what about localized values?
 
                 LocalizedStrings languageToLabels = ontologyLabels.get(annotationPropertyIri);
 
-		// For each language the label of the annotation has been localised into
-                for(String language : languageToLabels.getLanguages()) {
+                // For each language the label of the annotation has been localised into
+                for (String language : languageToLabels.getLanguages()) {
 
-		    // For each label the property has in this language
+                    // For each label the property has in this language
                     List<String> propertyLabels = languageToLabels.getStrings(language);
-                    for(String label : propertyLabels) {
+                    for (String label : propertyLabels) {
 
                         if (!annotations.containsKey(language)) {
                             annotations.put(language, new HashMap<>());
                         }
 
-			Map<String, List<String>> annos = annotations.get(language);
+                        Map<String, List<String>> annos = annotations.get(language);
 
-			if(!annos.containsKey(label)) {
-			    annos.put(label, new ArrayList<>());
-			}
+                        if (!annos.containsKey(label)) {
+                            annos.put(label, new ArrayList<>());
+                        }
 
                         annos.get(label).add(theValue.get());
                     }
@@ -616,7 +601,7 @@ protected void indexTerms(Collection<OWLEntity> entities) {
 
         getLogger().debug("Starting to index " + entities.size() + " entities");
 
-        for (OWLEntity entity: entities) {
+        for (OWLEntity entity : entities) {
             // get all the annotation properties
             evaluateAllAnnotationsValues(entity);
 
@@ -626,18 +611,18 @@ protected void indexTerms(Collection<OWLEntity> entities) {
                 setClassAccession(entity.getIRI(), shortForm.get());
 
                 // if no label, create one from shortform
-		LocalizedStrings labels = ontologyLabels.get(entity.getIRI());
-
-		if(labels == null) {
-			labels = new LocalizedStrings();
-			labels.addDefaultString(shortForm.get());
-		} else {
-			if(labels.getDefaultStrings().size() == 0) {
-				labels.addDefaultString(shortForm.get());
-			}
+                LocalizedStrings labels = ontologyLabels.get(entity.getIRI());
+
+                if (labels == null) {
+                    labels = new LocalizedStrings();
+                    labels.addDefaultString(shortForm.get());
+                } else {
+                    if (labels.getDefaultStrings().size() == 0) {
+                        labels.addDefaultString(shortForm.get());
+                    }
                 }
 
-		setClassLabels(entity.getIRI(), labels);
+                setClassLabels(entity.getIRI(), labels);
 
                 Optional<String> oboForm = getOBOid(shortForm.get());
 
@@ -685,12 +670,12 @@ public void visit(OWLDataProperty property) {
                 public void visit(OWLNamedIndividual individual) {
 
                     individuals.add(individual.getIRI());
-                     try {
+                    try {
                         // add types as parents
                         indexIndividualTypes(individual);
                         indexPropertyRelations(individual);
 
-                    } catch(OWLOntologyCreationException e) {
+                    } catch (OWLOntologyCreationException e) {
                         getLogger().error("unable to index individuals, unable to create reasoner", e);
                     }
 
@@ -717,25 +702,29 @@ public void doDefault(Object object) {
 
     private void indexIndividualTypes(OWLNamedIndividual individual) throws OWLOntologyCreationException {
         Set<IRI> instanceTypes = new HashSet<IRI>();
-        Map<IRI,Collection<IRI>> instanceClassRelations = new HashMap<IRI,Collection<IRI>>();
-        Map<IRI,Collection<IRI>> instanceRelations = new HashMap<IRI,Collection<IRI>>();
+        Map<IRI, Collection<IRI>> instanceClassRelations = new HashMap<IRI, Collection<IRI>>();
+        Map<IRI, Collection<IRI>> instanceRelations = new HashMap<IRI, Collection<IRI>>();
 
         OWLReasoner reasoner = getOWLReasoner(ontology);
-        reasoner.getTypes(individual,true).getFlattened().forEach(c->instanceTypes.add(c.getIRI()));
+        reasoner.getTypes(individual, true).getFlattened().forEach(c -> instanceTypes.add(c.getIRI()));
+
+        Set<String> instanceAnonymousTypes = new HashSet<>();
 
         EntitySearcher.getTypes(individual, ontology).forEach(expression -> {
-            if (expression.isAnonymous())  {
+
+            if (expression.isAnonymous()) {
                 if (expression instanceof OWLObjectSomeValuesFrom) {
                     indexIndividualsToExistentialRestriction(instanceClassRelations, instanceRelations,
                             (OWLObjectSomeValuesFrom) expression);
-                } else if(expression instanceof OWLObjectHasValue) {
+                } else if (expression instanceof OWLObjectHasValue) {
                     indexIndividualsToExistentialRestriction(instanceClassRelations, instanceRelations,
                             (OWLObjectSomeValuesFrom) ((OWLObjectHasValue) expression).asSomeValuesFrom());
                 }
+                // store anonymous type as string
+                instanceAnonymousTypes.add(renderHtml(expression));
             }
         });
 
-
         if (!instanceTypes.isEmpty()) {
             setDirectTypes(individual.getIRI(), instanceTypes);
         }
@@ -745,12 +734,16 @@ private void indexIndividualTypes(OWLNamedIndividual individual) throws OWLOntol
         if (!instanceRelations.isEmpty()) {
             setRelatedIndividuals(individual.getIRI(), instanceRelations);
         }
+
+        if (!instanceAnonymousTypes.isEmpty()) {
+            setAnonymousTypeDescriptions(individual.getIRI(), instanceAnonymousTypes);
+        }
     }
 
     private void indexIndividualsToExistentialRestriction(Map<IRI, Collection<IRI>> instanceClassRelations,
-        Map<IRI, Collection<IRI>> instanceRelations, OWLObjectSomeValuesFrom objectSomeValuesFrom) {
+                                                          Map<IRI, Collection<IRI>> instanceRelations, OWLObjectSomeValuesFrom objectSomeValuesFrom) {
 
-      //we cover only the specific case of an existential restriction to a named class,
+        //we cover only the specific case of an existential restriction to a named class,
         //no inference, no syntactic equivalence (R some (A and A)
         if (!objectSomeValuesFrom.getProperty().isAnonymous()) {
             OWLClassExpression classExpressionFiller = objectSomeValuesFrom.getFiller();
@@ -761,19 +754,19 @@ private void indexIndividualsToExistentialRestriction(Map<IRI, Collection<IRI>>
                     instanceClassRelations.put(objectProperty.getIRI(), new HashSet<IRI>());
                 }
                 instanceClassRelations.get(objectProperty.getIRI()).add(
-                    objectSomeValuesFrom.getFiller().asOWLClass().getIRI());
+                        objectSomeValuesFrom.getFiller().asOWLClass().getIRI());
 
-            } else if(classExpressionFiller instanceof OWLObjectOneOf) {
+            } else if (classExpressionFiller instanceof OWLObjectOneOf) {
                 indexRelationsFromExistentialRestrictionsToNominals(instanceRelations,
-                    (OWLObjectOneOf) classExpressionFiller, objectProperty);
+                        (OWLObjectOneOf) classExpressionFiller, objectProperty);
             }
         }
     }
 
     private void indexRelationsFromExistentialRestrictionsToNominals(
-        Map<IRI, Collection<IRI>> instanceRelations, OWLObjectOneOf objectOneOf,
-        OWLObjectProperty objectProperty) {
-        if(objectOneOf.getIndividuals().size()==1) { // If there is more than one, we cannot assume a relationship.
+            Map<IRI, Collection<IRI>> instanceRelations, OWLObjectOneOf objectOneOf,
+            OWLObjectProperty objectProperty) {
+        if (objectOneOf.getIndividuals().size() == 1) { // If there is more than one, we cannot assume a relationship.
             for (OWLIndividual individual : objectOneOf.getIndividuals()) {
                 if (individual.isNamed()) {
                     if (!instanceRelations.containsKey(objectProperty.getIRI())) {
@@ -802,44 +795,44 @@ private void indexSubAnnotationPropertyRelations(OWLAnnotationProperty property)
     }
 
     private Set<IRI> findAllDirectAndIndirectSuperProperties(OWLObjectProperty objectProperty,
-    		Set<IRI> indirectSuperProperties, Set<OWLOntology> ontologyImportClosure) {
+                                                             Set<IRI> indirectSuperProperties, Set<OWLOntology> ontologyImportClosure) {
         try {
             EntitySearcher.getSuperProperties(objectProperty, ontologyImportClosure.stream()).forEach(
-                superObjectPropertyExpression -> {
-                    if (!superObjectPropertyExpression.isAnonymous()) {
-                        IRI superObjectPropertyIRI = superObjectPropertyExpression.asOWLObjectProperty().getIRI();
-                        if (!indirectSuperProperties.contains(superObjectPropertyIRI)) {
-                            indirectSuperProperties.add(superObjectPropertyIRI);
-                            findAllDirectAndIndirectSuperProperties(superObjectPropertyExpression.asOWLObjectProperty(),
-                                    indirectSuperProperties, ontologyImportClosure);
+                    superObjectPropertyExpression -> {
+                        if (!superObjectPropertyExpression.isAnonymous()) {
+                            IRI superObjectPropertyIRI = superObjectPropertyExpression.asOWLObjectProperty().getIRI();
+                            if (!indirectSuperProperties.contains(superObjectPropertyIRI)) {
+                                indirectSuperProperties.add(superObjectPropertyIRI);
+                                findAllDirectAndIndirectSuperProperties(superObjectPropertyExpression.asOWLObjectProperty(),
+                                        indirectSuperProperties, ontologyImportClosure);
+                            }
                         }
-                    }
-                });
+                    });
         } catch (Throwable t) {
-           getLogger().error("Problematic object property = " + objectProperty.getIRI(), t);
+            getLogger().error("Problematic object property = " + objectProperty.getIRI(), t);
         }
-    	return indirectSuperProperties;
+        return indirectSuperProperties;
     }
 
     private Set<IRI> findAllDirectAndIndirectSubProperties(OWLObjectProperty objectProperty,
-    		Set<IRI> indirectSubProperties, Set<OWLOntology> ontologyImportClosure) {
+                                                           Set<IRI> indirectSubProperties, Set<OWLOntology> ontologyImportClosure) {
 
         try {
             EntitySearcher.getSuperProperties(objectProperty, ontologyImportClosure.stream()).forEach(
-                subObjectPropertyExpression -> {
-                    IRI subObjectPropertyIRI = subObjectPropertyExpression.asOWLObjectProperty().getIRI();
-                    if (!subObjectPropertyExpression.isAnonymous() &&
-                            !indirectSubProperties.contains(subObjectPropertyIRI)) {
-
-                        indirectSubProperties.add(subObjectPropertyIRI);
-                        findAllDirectAndIndirectSubProperties(subObjectPropertyExpression.asOWLObjectProperty(),
-                                indirectSubProperties, ontologyImportClosure);
-                    }
-                });
+                    subObjectPropertyExpression -> {
+                        IRI subObjectPropertyIRI = subObjectPropertyExpression.asOWLObjectProperty().getIRI();
+                        if (!subObjectPropertyExpression.isAnonymous() &&
+                                !indirectSubProperties.contains(subObjectPropertyIRI)) {
+
+                            indirectSubProperties.add(subObjectPropertyIRI);
+                            findAllDirectAndIndirectSubProperties(subObjectPropertyExpression.asOWLObjectProperty(),
+                                    indirectSubProperties, ontologyImportClosure);
+                        }
+                    });
         } catch (Throwable t) {
             getLogger().error("Problematic object property = " + objectProperty.getIRI(), t);
         }
-    	return indirectSubProperties;
+        return indirectSubProperties;
     }
 
     private void indexSubPropertyRelations(OWLObjectProperty property) {
@@ -852,40 +845,40 @@ private void indexSubPropertyRelations(OWLObjectProperty property) {
         Set<OWLOntology> ontologyImportClosure = ontology.getImportsClosure();
         try {
             EntitySearcher.getSuperProperties(property, ontologyImportClosure.stream()).filter(
-                owlObjectProperty -> (!owlObjectProperty.isAnonymous() && owlObjectProperty.getInverseProperty() != null)).forEach(
-                owlProperty -> {
-                    directSuperProperties.add(owlProperty.asOWLObjectProperty().getIRI());
-                });
+                    owlObjectProperty -> (!owlObjectProperty.isAnonymous() && owlObjectProperty.getInverseProperty() != null)).forEach(
+                    owlProperty -> {
+                        directSuperProperties.add(owlProperty.asOWLObjectProperty().getIRI());
+                    });
         } catch (Throwable t) {
             getLogger().error("Problematic object property = " + property.getIRI(), t);
         }
 
         setDirectParents(property.getIRI(), directSuperProperties);
         setAllParents(property.getIRI(), findAllDirectAndIndirectSuperProperties(property,
-        		indirectSuperProperties, ontologyImportClosure));
+                indirectSuperProperties, ontologyImportClosure));
 //        getLogger().debug("indexSubPropertyRelations: " + property + " directSuperProperties = " + directSuperProperties);
 //        getLogger().debug("indexSubPropertyRelations: " + property + " indirectSuperProperties = " + indirectSuperProperties);
 
         Set<IRI> directSubProperties = new HashSet<>();
         try {
             EntitySearcher.getSubProperties(property, ontologyImportClosure.stream()).filter(
-                owlObjectProperty -> !owlObjectProperty.isAnonymous()).forEach(
-                owlProperty -> {
-                    directSubProperties.add(owlProperty.asOWLObjectProperty().getIRI());
-                });
+                    owlObjectProperty -> !owlObjectProperty.isAnonymous()).forEach(
+                    owlProperty -> {
+                        directSubProperties.add(owlProperty.asOWLObjectProperty().getIRI());
+                    });
         } catch (Throwable t) {
             getLogger().error("Problematic object property = " + property.getIRI());
         }
 
         setDirectChildren(property.getIRI(), directSubProperties);
         setAllParents(property.getIRI(), findAllDirectAndIndirectSubProperties(property,
-        		indirectSubProperties, ontologyImportClosure));
+                indirectSubProperties, ontologyImportClosure));
         getLogger().debug("indexSubPropertyRelations: " + property + " directSubProperties = " + directSubProperties);
         getLogger().debug("indexSubPropertyRelations: " + property + " indirectSubProperties = " + indirectSubProperties);
     }
 
 
-    protected  void indexSubclassRelations(OWLClass owlClass) throws OWLOntologyCreationException {
+    protected void indexSubclassRelations(OWLClass owlClass) throws OWLOntologyCreationException {
         getLogger().debug("indexSubclassRelations {}", owlClass);
         OWLReasoner reasoner = getOWLReasoner(ontology);
 
@@ -913,7 +906,7 @@ protected  void indexSubclassRelations(OWLClass owlClass) throws OWLOntologyCrea
                 owlVocabulary);
 //        getLogger().debug("indexSubclassRelations directChildTerms for {} count  {}", owlClass, directChildTerms.size());
         if (directChildTerms.size() > 0)
-          setDirectChildren(owlClass.getIRI(), directChildTerms) ;
+            setDirectChildren(owlClass.getIRI(), directChildTerms);
 
         // get all children
         Set<IRI> allDescendantTerms = removeExcludedIRI(
@@ -921,8 +914,8 @@ protected  void indexSubclassRelations(OWLClass owlClass) throws OWLOntologyCrea
                         .map(OWLNamedObject::getIRI)
                         .collect(Collectors.toSet()),
                 owlVocabulary);
-        if (allDescendantTerms.size() >0)
-          setAllChildren(owlClass.getIRI(), allDescendantTerms);
+        if (allDescendantTerms.size() > 0)
+            setAllChildren(owlClass.getIRI(), allDescendantTerms);
 
         // get parents
         Set<IRI> directParentTerms =
@@ -932,8 +925,8 @@ protected  void indexSubclassRelations(OWLClass owlClass) throws OWLOntologyCrea
                                 .collect(Collectors.toSet()),
                         owlVocabulary);
 
-        if (directParentTerms.size()>0)
-          setDirectParents(owlClass.getIRI(), directParentTerms);
+        if (directParentTerms.size() > 0)
+            setDirectParents(owlClass.getIRI(), directParentTerms);
 
         // get all parents
         Set<IRI> allAncestorTerms =
@@ -943,70 +936,70 @@ protected  void indexSubclassRelations(OWLClass owlClass) throws OWLOntologyCrea
                                 .collect(Collectors.toSet()),
                         owlVocabulary);
 
-        if (allAncestorTerms.size()>0)
-          setAllParents(owlClass.getIRI(), allAncestorTerms);
+        if (allAncestorTerms.size() > 0)
+            setAllParents(owlClass.getIRI(), allAncestorTerms);
 
         // map of related parent terms for hierarchy views
         Map<IRI, Collection<IRI>> relatedParentTerms = new HashMap<>();
 
         // find direct related terms
         Map<IRI, Collection<IRI>> relatedTerms = new HashMap<>();
-        Map<IRI,Collection<IRI>> relatedIndividualsToClasses = new HashMap<>();
+        Map<IRI, Collection<IRI>> relatedIndividualsToClasses = new HashMap<>();
 
         Set<String> relatedDescriptions = new HashSet<>();
 
         EntitySearcher.getSuperClasses(owlClass, getManager().ontologies()).forEach(expression -> {
 
-                // only want existential with named class as filler
-                if (expression.isAnonymous()) {
+            // only want existential with named class as filler
+            if (expression.isAnonymous()) {
 
-                    if (expression instanceof OWLObjectSomeValuesFrom) {
+                if (expression instanceof OWLObjectSomeValuesFrom) {
 
-                        OWLObjectSomeValuesFrom someValuesFrom = (OWLObjectSomeValuesFrom) expression;
+                    OWLObjectSomeValuesFrom someValuesFrom = (OWLObjectSomeValuesFrom) expression;
 
-                        if (!someValuesFrom.getFiller().isAnonymous() && ! someValuesFrom.getProperty().isAnonymous()) {
-                            IRI propertyIRI = someValuesFrom.getProperty().asOWLObjectProperty().getIRI();
-                            IRI relatedTerm = someValuesFrom.getFiller().asOWLClass().getIRI();
+                    if (!someValuesFrom.getFiller().isAnonymous() && !someValuesFrom.getProperty().isAnonymous()) {
+                        IRI propertyIRI = someValuesFrom.getProperty().asOWLObjectProperty().getIRI();
+                        IRI relatedTerm = someValuesFrom.getFiller().asOWLClass().getIRI();
 
-                            // skip terms that are related to themselves as this can cause nasty cycles
+                        // skip terms that are related to themselves as this can cause nasty cycles
 
-                            if (!relatedTerms.containsKey(propertyIRI)) {
-                                relatedTerms.put(propertyIRI, new HashSet<>());
-                            }
-                            relatedTerms.get(propertyIRI).add(relatedTerm);
-
-                            // check if hierarchical
-                            if (hierarchicalRels.contains(propertyIRI) || isPartOf(propertyIRI) ) {
-                                if (owlClass.getIRI().equals(relatedTerm)) {
-                                    getLogger().warn("Ignoring Iri that is related to itself: " + owlClass.getIRI());
-                                } else  {
-                                    if (!relatedParentTerms.containsKey(propertyIRI)) {
-                                        relatedParentTerms.put(propertyIRI, new HashSet<>());
-                                    }
-                                    relatedParentTerms.get(propertyIRI).add(relatedTerm);
-                                    addRelatedChildTerm(relatedTerm, owlClass.getIRI());
+                        if (!relatedTerms.containsKey(propertyIRI)) {
+                            relatedTerms.put(propertyIRI, new HashSet<>());
+                        }
+                        relatedTerms.get(propertyIRI).add(relatedTerm);
+
+                        // check if hierarchical
+                        if (hierarchicalRels.contains(propertyIRI) || isPartOf(propertyIRI)) {
+                            if (owlClass.getIRI().equals(relatedTerm)) {
+                                getLogger().warn("Ignoring Iri that is related to itself: " + owlClass.getIRI());
+                            } else {
+                                if (!relatedParentTerms.containsKey(propertyIRI)) {
+                                    relatedParentTerms.put(propertyIRI, new HashSet<>());
                                 }
-
-
+                                relatedParentTerms.get(propertyIRI).add(relatedTerm);
+                                addRelatedChildTerm(relatedTerm, owlClass.getIRI());
                             }
 
-                        } else if (someValuesFrom.getFiller().isAnonymous() && !someValuesFrom.getProperty().isAnonymous()) {
-                            indexTermToIndividualRelations(someValuesFrom,relatedIndividualsToClasses);
+
                         }
 
-                    } else if (expression instanceof OWLObjectHasValue) {
-                        OWLObjectSomeValuesFrom someValuesFrom = (OWLObjectSomeValuesFrom)((OWLObjectHasValue) expression).asSomeValuesFrom();
-                        indexTermToIndividualRelations(someValuesFrom,relatedIndividualsToClasses);
+                    } else if (someValuesFrom.getFiller().isAnonymous() && !someValuesFrom.getProperty().isAnonymous()) {
+                        indexTermToIndividualRelations(someValuesFrom, relatedIndividualsToClasses);
                     }
 
-
-                    // store stringified form of class description
-                    relatedDescriptions.add(renderHtml(expression));
+                } else if (expression instanceof OWLObjectHasValue) {
+                    OWLObjectSomeValuesFrom someValuesFrom = (OWLObjectSomeValuesFrom) ((OWLObjectHasValue) expression).asSomeValuesFrom();
+                    indexTermToIndividualRelations(someValuesFrom, relatedIndividualsToClasses);
                 }
+
+
+                // store stringified form of class description
+                relatedDescriptions.add(renderHtml(expression));
+            }
         });
 
         if (!relatedTerms.isEmpty()) {
-            setRelatedTerms(owlClass.getIRI(), relatedTerms );
+            setRelatedTerms(owlClass.getIRI(), relatedTerms);
         }
 
         if (!relatedIndividualsToClasses.isEmpty()) {
@@ -1024,22 +1017,23 @@ protected  void indexSubclassRelations(OWLClass owlClass) throws OWLOntologyCrea
     }
 
     private void indexTermToIndividualRelations(OWLObjectSomeValuesFrom someValuesFrom,
-        Map<IRI, Collection<IRI>> relatedIndividualsToClasses) {
+                                                Map<IRI, Collection<IRI>> relatedIndividualsToClasses) {
 
-      OWLClassExpression classExpression = someValuesFrom.getFiller();
-        if(someValuesFrom.getProperty().isAnonymous()) {
+        OWLClassExpression classExpression = someValuesFrom.getFiller();
+        if (someValuesFrom.getProperty().isAnonymous()) {
             //Must be anonymous property
             return;
         }
         OWLObjectProperty objectProperty = someValuesFrom.getProperty().asOWLObjectProperty();
-        if(classExpression instanceof OWLObjectOneOf) {
+        if (classExpression instanceof OWLObjectOneOf) {
             indexRelationsFromExistentialRestrictionsToNominals(relatedIndividualsToClasses,
-                (OWLObjectOneOf) classExpression, objectProperty);
+                    (OWLObjectOneOf) classExpression, objectProperty);
         }
     }
 
     /**
      * Bit of a hack to try and detect non standard 'part of' predicates
+     *
      * @param propertyIri
      * @return
      */
@@ -1051,7 +1045,7 @@ private boolean isPartOf(IRI propertyIri) {
         return false;
     }
 
-    private String renderHtml (OWLObject owlObject) {
+    private String renderHtml(OWLObject owlObject) {
         StringWriter stringWriter = new StringWriter();
         PrintWriter printWriter = new PrintWriter(stringWriter);
         OWLHTMLVisitor owlhtmlVisitor = new OWLHTMLVisitor(provider, printWriter);
@@ -1093,7 +1087,7 @@ private void indexEquivalentRelations(OWLClass owlClass) throws OWLOntologyCreat
 
     private void indexPropertyRelations(OWLNamedIndividual individual) throws OWLOntologyCreationException {
 
-        Map<IRI,Collection<IRI>> instanceInstanceRelations = new HashMap<IRI,Collection<IRI>>();
+        Map<IRI, Collection<IRI>> instanceInstanceRelations = new HashMap<IRI, Collection<IRI>>();
 
         //The following works, will most likely be way too computationally expensive though
         //extractInferredRelationsFromIndividualObjectPropertyAssertions(individual, instanceInstanceRelations);
@@ -1109,14 +1103,14 @@ private void extractAssertedRelationsFromIndividualObjectPropertyAssertions(OWLN
                 EntitySearcher.getObjectPropertyValues(individual, ontology);
 
         for (OWLObjectPropertyExpression rel : assertedRelations.keySet()) {
-            if(!rel.isAnonymous()) {
+            if (!rel.isAnonymous()) {
                 IRI reliri = rel.asOWLObjectProperty().getIRI();
-                for(OWLIndividual i:assertedRelations.get(rel)) {
+                for (OWLIndividual i : assertedRelations.get(rel)) {
                     //no inference, no negation or anonymous individuals
-                    if(!i.isAnonymous()) {
+                    if (!i.isAnonymous()) {
 
-                        if(!instanceInstanceRelations.containsKey(reliri)) {
-                            instanceInstanceRelations.put(reliri,new HashSet<IRI>());
+                        if (!instanceInstanceRelations.containsKey(reliri)) {
+                            instanceInstanceRelations.put(reliri, new HashSet<IRI>());
                         }
                         instanceInstanceRelations.get(reliri).add(i.asOWLNamedIndividual().getIRI());
                     }
@@ -1143,9 +1137,9 @@ private void extractInferredRelationsFromIndividualObjectPropertyAssertions(OWLN
         relations.remove(ontology.getOWLOntologyManager().getOWLDataFactory().getOWLTopObjectProperty());
 
         for (OWLObjectPropertyExpression rel : relations) {
-            if(!rel.isAnonymous()) {
+            if (!rel.isAnonymous()) {
                 IRI reliri = rel.asOWLObjectProperty().getIRI();
-                for (OWLNamedIndividual i : reasoner.getObjectPropertyValues(individual,rel.asOWLObjectProperty()).getFlattened()) {
+                for (OWLNamedIndividual i : reasoner.getObjectPropertyValues(individual, rel.asOWLObjectProperty()).getFlattened()) {
                     if (!instanceInstanceRelations.containsKey(reliri)) {
                         instanceInstanceRelations.put(reliri, new HashSet<IRI>());
                     }
@@ -1165,7 +1159,7 @@ protected Optional<String> extractShortForm(IRI entityIRI) {
         getLogger().trace("Attempting to extract fragment name of IRI '" + entityIRI + "'");
 
         // special case for URN schemes: https://www.w3.org/Addressing/URL/URI_URN.html
-        if(entityIRI.toString().startsWith("urn:")) {
+        if (entityIRI.toString().startsWith("urn:")) {
             return Optional.of(entityIRI.toString().substring(4));
         }
 
@@ -1181,29 +1175,26 @@ protected Optional<String> extractShortForm(IRI entityIRI) {
         }
 
         try {
-	        if (entityIRI.getRemainder().isPresent()) {
-	            return Optional.of(entityIRI.getRemainder().get());
-	        }
-	        else if (entityIRI.toURI().getPath() != null) {
-	            // no fragment, but there is a path so try and extract the final part...
-	            if (entityIRI.toURI().getPath().contains("/")) {
-	                getLogger().trace("Extracting fragment name using final part of the path of the ONTOLOGY_URI");
-	                return Optional.of(entityIRI.toURI().getPath().substring(entityIRI.toURI().getPath().lastIndexOf('/') + 1));
-	            }
-	            else {
-	                // no final path part, so just return whole path
-	                getLogger().trace("Extracting fragment name using the path of the ONTOLOGY_URI");
-	                return Optional.of(entityIRI.toURI().getPath());
-	            }
-	        }
-	        else {
-	            // no fragment, path is null, we've run out of rules so don't shorten
-	            getLogger().trace("No rules to shorten this ONTOLOGY_URI could be found (" + entityIRI + ")");
-	            return Optional.empty();
-	        }
+            if (entityIRI.getRemainder().isPresent()) {
+                return Optional.of(entityIRI.getRemainder().get());
+            } else if (entityIRI.toURI().getPath() != null) {
+                // no fragment, but there is a path so try and extract the final part...
+                if (entityIRI.toURI().getPath().contains("/")) {
+                    getLogger().trace("Extracting fragment name using final part of the path of the ONTOLOGY_URI");
+                    return Optional.of(entityIRI.toURI().getPath().substring(entityIRI.toURI().getPath().lastIndexOf('/') + 1));
+                } else {
+                    // no final path part, so just return whole path
+                    getLogger().trace("Extracting fragment name using the path of the ONTOLOGY_URI");
+                    return Optional.of(entityIRI.toURI().getPath());
+                }
+            } else {
+                // no fragment, path is null, we've run out of rules so don't shorten
+                getLogger().trace("No rules to shorten this ONTOLOGY_URI could be found (" + entityIRI + ")");
+                return Optional.empty();
+            }
         } catch (IllegalArgumentException iae) {
             getLogger().debug("Workaround for IllegalArgumentException for :" + entityIRI);
-        	return Optional.empty();
+            return Optional.empty();
         }
     }
 
@@ -1213,8 +1204,7 @@ private Optional<String> getOBOid(String fragment) {
         if (matcher.find()) {
             String newId = matcher.group(2) + ":" + matcher.group(3);
             return Optional.of(newId);
-        }
-        else if (fragment.split(":").length == 2 && fragment.split(":")[0].toLowerCase().equals(getOntologyName().toLowerCase())) {
+        } else if (fragment.split(":").length == 2 && fragment.split(":")[0].toLowerCase().equals(getOntologyName().toLowerCase())) {
             // if the fragment already contains a :
             return Optional.of(fragment);
         }
@@ -1230,11 +1220,10 @@ protected Optional<String> evaluateLabelAnnotationValue(OWLEntity entity, OWLAnn
             Optional<String> fragment = extractShortForm(entity.getIRI());
             if (fragment.isPresent()) {
                 return Optional.of(fragment.get());
-            }
-            else {
+            } else {
                 getLogger().warn("OWLEntity " + entity + " contains no label. " +
                         "No labels for this class will be loaded.");
-                return  Optional.of(entity.toStringID());
+                return Optional.of(entity.toStringID());
             }
         }
         return label;
@@ -1255,178 +1244,171 @@ protected void evaluateAllAnnotationsValues(OWLEntity owlEntity) {
         LocalizedStrings existingClassLabels = ontologyLabels.get(owlEntityIRI);
 
         LocalizedStrings classLabels = existingClassLabels != null ?
-		existingClassLabels : new LocalizedStrings();
+                existingClassLabels : new LocalizedStrings();
 
         Collection<OBODefinitionCitation> definitionCitations = new HashSet<>();
         Collection<OBOSynonym> oboSynonyms = new HashSet<>();
         Collection<OBOXref> oboEntityXrefs = new HashSet<>();
 
         // loop through other annotations in the imports closure
-        for (OWLOntology anOntology : getManager().ontologies().collect(Collectors.toSet())){
-                EntitySearcher.getAnnotationAssertionAxioms(owlEntity, anOntology).forEach(annotationAssertionAxiom -> {
-                        OWLAnnotationProperty annotationProperty = annotationAssertionAxiom.getProperty();
-                        IRI annotationPropertyIRI = annotationProperty.getIRI();
-                        OWLAnnotationValue value = annotationAssertionAxiom.getValue();
-
-			// blank string = default lang
-                        String lang = "";
-
-			// but take lang from the value if it is present
-                        if(value.isLiteral()) {
-                            if(((OWLLiteral) value).hasLang()) {
-                                lang = ((OWLLiteral) value).getLang();
-				ontologyLanguages.add(lang);
-                            }
-                        }
+        for (OWLOntology anOntology : getManager().ontologies().collect(Collectors.toSet())) {
+            EntitySearcher.getAnnotationAssertionAxioms(owlEntity, anOntology).forEach(annotationAssertionAxiom -> {
+                OWLAnnotationProperty annotationProperty = annotationAssertionAxiom.getProperty();
+                IRI annotationPropertyIRI = annotationProperty.getIRI();
+                OWLAnnotationValue value = annotationAssertionAxiom.getValue();
+
+                // blank string = default lang
+                String lang = "";
+
+                // but take lang from the value if it is present
+                if (value.isLiteral()) {
+                    if (((OWLLiteral) value).hasLang()) {
+                        lang = ((OWLLiteral) value).getLang();
+                        ontologyLanguages.add(lang);
+                    }
+                }
 
 
-                        if (getLabelIRI().equals(annotationPropertyIRI)) {
-                            classLabels.addString(lang, evaluateLabelAnnotationValue(
-                                    owlEntity, value).get());
-                        }
-                        else if (getSynonymIRIs().contains(annotationPropertyIRI)) {
-                            synonyms.addString(lang, getOWLAnnotationValueAsString(value).get());
-                        }
-                        else if (getDefinitionIRIs().contains(annotationPropertyIRI)) {
-                            definitions.addString(lang, getOWLAnnotationValueAsString(value).get());
+                if (getLabelIRI().equals(annotationPropertyIRI)) {
+                    classLabels.addString(lang, evaluateLabelAnnotationValue(
+                            owlEntity, value).get());
+                } else if (getSynonymIRIs().contains(annotationPropertyIRI)) {
+                    synonyms.addString(lang, getOWLAnnotationValueAsString(value).get());
+                } else if (getDefinitionIRIs().contains(annotationPropertyIRI)) {
+                    definitions.addString(lang, getOWLAnnotationValueAsString(value).get());
+                } else if (annotationPropertyIRI.equals(Namespaces.OBOINOWL.createIRI("inSubset")) && value instanceof IRI) {
+                    if (extractShortForm((IRI) value).isPresent()) {
+                        slims.add(extractShortForm((IRI) value).get());
+                    }
+                } else if (annotationPropertyIRI.equals(Namespaces.OWL.createIRI("deprecated"))) {
+                    addObsoleteTerms(owlEntityIRI);
+                } else {
+                    if (getOWLAnnotationValueAsString(value).isPresent()) {
+                        // initialise maps if first time
+                        if (!termAnnotations.containsKey(owlEntityIRI)) {
+                            HashMap<IRI, LocalizedStrings> newMap = new HashMap<>();
+                            newMap.put(annotationPropertyIRI, new LocalizedStrings());
+                            termAnnotations.put(owlEntityIRI, newMap);
                         }
-                        else if (annotationPropertyIRI.equals(Namespaces.OBOINOWL.createIRI("inSubset")) && value instanceof IRI) {
-                            if (extractShortForm( (IRI) value).isPresent()) {
-                                slims.add(extractShortForm( (IRI) value).get());
-                            }
+
+                        if (!termAnnotations.get(owlEntityIRI).containsKey(annotationPropertyIRI)) {
+                            termAnnotations.get(owlEntityIRI).put(annotationPropertyIRI, new LocalizedStrings());
                         }
-                        else if (annotationPropertyIRI.equals(Namespaces.OWL.createIRI("deprecated"))) {
-                            addObsoleteTerms(owlEntityIRI);
+
+                        if (value instanceof IRI) {
+                            termAnnotations.get(owlEntityIRI).get(annotationPropertyIRI).addString(
+                                    lang, annotationAssertionAxiom.getValue().toString());
+                        } else {
+                            termAnnotations.get(owlEntityIRI).get(annotationPropertyIRI).addString(
+                                    lang, getOWLAnnotationValueAsString(value).get());
                         }
-                        else {
-                            if (getOWLAnnotationValueAsString(value).isPresent()) {
-                                // initialise maps if first time
-                                if (!termAnnotations.containsKey(owlEntityIRI)) {
-                                    HashMap<IRI, LocalizedStrings> newMap = new HashMap<>();
-                                    newMap.put(annotationPropertyIRI, new LocalizedStrings());
-                                    termAnnotations.put(owlEntityIRI, newMap);
-                                }
+                    }
+                }
 
-                                if (!termAnnotations.get(owlEntityIRI).containsKey(annotationPropertyIRI)) {
-                                    termAnnotations.get(owlEntityIRI).put(annotationPropertyIRI, new LocalizedStrings());
-                                }
+                // pull out term replaced by
+                if (annotationPropertyIRI.equals(Namespaces.OBO.createIRI("IAO_0100001"))) {
+                    addTermReplacedBy(owlEntityIRI, getOWLAnnotationValueAsString(value).get());
+                }
 
-                                if (value instanceof IRI) {
-                                    termAnnotations.get(owlEntityIRI).get(annotationPropertyIRI).addString(
-                                        lang, annotationAssertionAxiom.getValue().toString());
-                                }
-                                else {
-                                    termAnnotations.get(owlEntityIRI).get(annotationPropertyIRI).addString(
-                                        lang, getOWLAnnotationValueAsString(value).get());
-                                }
-                            }
-                        }
+                // collect any obo definition xrefs
+                if (annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.DEFINITION)) {
+                    if (!annotationAssertionAxiom.getAnnotations().isEmpty()) {
 
-                        // pull out term replaced by
-                        if (annotationPropertyIRI.equals(Namespaces.OBO.createIRI("IAO_0100001"))) {
-                            addTermReplacedBy(owlEntityIRI, getOWLAnnotationValueAsString(value).get());
+                        OBODefinitionCitation definitionCitation = new OBODefinitionCitation();
+                        Collection<OBOXref> oboXrefs = new HashSet<>();
+                        for (OWLAnnotation defAnnotation : annotationAssertionAxiom.getAnnotations()) {
+                            oboXrefs.add(extractOBOXrefs(defAnnotation));
                         }
+                        definitionCitation.setDefinition(getOWLAnnotationValueAsString(value).get());
+                        definitionCitation.setOboXrefs(oboXrefs);
+                        definitionCitations.add(definitionCitation);
+                    }
+                }
 
-                        // collect any obo definition xrefs
-                        if (annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.DEFINITION)) {
-                            if (!annotationAssertionAxiom.getAnnotations().isEmpty()) {
+                // collect any obo synonym xrefs
+                if (
+                        annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.EXACT_SYNONYM)
+                                || annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.RELATED_SYNONYM)
+                                || annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.NARROW_SYNONYM)
+                                || annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.BROAD_SYNONYM)
 
-                                OBODefinitionCitation definitionCitation = new OBODefinitionCitation();
-                                Collection<OBOXref> oboXrefs = new HashSet<>();
-                                for (OWLAnnotation defAnnotation : annotationAssertionAxiom.getAnnotations()) {
-                                    oboXrefs.add(extractOBOXrefs(defAnnotation));
-                                }
-                                definitionCitation.setDefinition(getOWLAnnotationValueAsString(value).get());
-                                definitionCitation.setOboXrefs(oboXrefs);
-                                definitionCitations.add(definitionCitation);
-                            }
-                        }
+                ) {
+                    if (!annotationAssertionAxiom.getAnnotations().isEmpty()) {
 
-                        // collect any obo synonym xrefs
-                        if (
-                                annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.EXACT_SYNONYM)
-                                        || annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.RELATED_SYNONYM)
-                                        || annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.NARROW_SYNONYM)
-                                        || annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.BROAD_SYNONYM)
-
-                        ) {
-                            if (!annotationAssertionAxiom.getAnnotations().isEmpty()) {
-
-                                OBOSynonym synonymCitation = new OBOSynonym();
-
-                                synonymCitation.setName(getOWLAnnotationValueAsString(annotationAssertionAxiom.getValue()).get());
-                                synonymCitation.setScope(annotationAssertionAxiom.getProperty().getIRI().getShortForm());
-                                Collection<OBOXref> oboXrefs = new HashSet<>();
-                                for (OWLAnnotation annotationAxiomAnnotation : annotationAssertionAxiom.getAnnotations()) {
-                                    if (annotationAxiomAnnotation.getProperty().getIRI().toString().equals(OboDefaults.SYNONYM_TYPE)) {
-                                        OWLAnnotationValue annoValue = annotationAxiomAnnotation.getValue();
-                                        if (value instanceof IRI) {
-                                            OWLAnnotationProperty owlAnnotationProperty = factory.getOWLAnnotationProperty((IRI) annoValue);
-                                            EntitySearcher.getAnnotations(owlAnnotationProperty, ontology).forEach(valueAnnotation -> {
-                                                if (valueAnnotation.getProperty().getIRI().equals(OWLRDFVocabulary.RDFS_LABEL.getIRI())) {
-                                                    String type = getOWLAnnotationValueAsString(valueAnnotation.getValue()).get();
-                                                    synonymCitation.setType(type);
-                                                }
-                                            });
+                        OBOSynonym synonymCitation = new OBOSynonym();
+
+                        synonymCitation.setName(getOWLAnnotationValueAsString(annotationAssertionAxiom.getValue()).get());
+                        synonymCitation.setScope(annotationAssertionAxiom.getProperty().getIRI().getShortForm());
+                        Collection<OBOXref> oboXrefs = new HashSet<>();
+                        for (OWLAnnotation annotationAxiomAnnotation : annotationAssertionAxiom.getAnnotations()) {
+                            if (annotationAxiomAnnotation.getProperty().getIRI().toString().equals(OboDefaults.SYNONYM_TYPE)) {
+                                OWLAnnotationValue annoValue = annotationAxiomAnnotation.getValue();
+                                if (value instanceof IRI) {
+                                    OWLAnnotationProperty owlAnnotationProperty = factory.getOWLAnnotationProperty((IRI) annoValue);
+                                    EntitySearcher.getAnnotations(owlAnnotationProperty, ontology).forEach(valueAnnotation -> {
+                                        if (valueAnnotation.getProperty().getIRI().equals(OWLRDFVocabulary.RDFS_LABEL.getIRI())) {
+                                            String type = getOWLAnnotationValueAsString(valueAnnotation.getValue()).get();
+                                            synonymCitation.setType(type);
                                         }
-                                    }
-                                    if (annotationAxiomAnnotation.getProperty().getIRI().toString().equals(OboDefaults.DBXREF)) {
-                                        oboXrefs.add(extractOBOXrefs(annotationAxiomAnnotation));
-                                    }
+                                    });
                                 }
-                                synonymCitation.setXrefs(oboXrefs);
-                                oboSynonyms.add(synonymCitation);
+                            }
+                            if (annotationAxiomAnnotation.getProperty().getIRI().toString().equals(OboDefaults.DBXREF)) {
+                                oboXrefs.add(extractOBOXrefs(annotationAxiomAnnotation));
                             }
                         }
+                        synonymCitation.setXrefs(oboXrefs);
+                        oboSynonyms.add(synonymCitation);
+                    }
+                }
 
-                        // collect any obo  xrefs
-                        if (annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.DBXREF)) {
-                            OBOXref oboXrefs = extractOBOXrefs(annotationAssertionAxiom.getAnnotation());
-                            if (!annotationAssertionAxiom.getAnnotations().isEmpty()) {
-                                for (OWLAnnotation axiomAnnotation : annotationAssertionAxiom.getAnnotations()) {
-                                    String description = getOWLAnnotationValueAsString(axiomAnnotation.getValue()).get();
-                                    oboXrefs.setDescription(description);
-                                }
-                            }
-                            oboEntityXrefs.add(oboXrefs);
+                // collect any obo  xrefs
+                if (annotationAssertionAxiom.getProperty().getIRI().toString().equals(OboDefaults.DBXREF)) {
+                    OBOXref oboXrefs = extractOBOXrefs(annotationAssertionAxiom.getAnnotation());
+                    if (!annotationAssertionAxiom.getAnnotations().isEmpty()) {
+                        for (OWLAnnotation axiomAnnotation : annotationAssertionAxiom.getAnnotations()) {
+                            String description = getOWLAnnotationValueAsString(axiomAnnotation.getValue()).get();
+                            oboXrefs.setDescription(description);
                         }
-                });
+                    }
+                    oboEntityXrefs.add(oboXrefs);
+                }
+            });
         }
 
-	setClassLabels(owlEntityIRI, classLabels);
+        setClassLabels(owlEntityIRI, classLabels);
 
         if (definitionCitations.size() > 0) {
             setOboDefinitionCitation(owlEntityIRI, definitionCitations);
         }
 
-        if (oboSynonyms.size() >0 ) {
+        if (oboSynonyms.size() > 0) {
             setOboSynonym(owlEntityIRI, oboSynonyms);
         }
 
-        if (oboEntityXrefs.size() >0 ) {
+        if (oboEntityXrefs.size() > 0) {
             setOboXref(owlEntityIRI, oboEntityXrefs);
         }
 
         if (synonyms.size() > 0) {
             setSynonyms(owlEntityIRI, synonyms);
         }
-        if (definitions.size() >0) {
+        if (definitions.size() > 0) {
             setDefinitions(owlEntityIRI, definitions);
         }
-        if (slims.size() >0) {
+        if (slims.size() > 0) {
             setSlims(owlEntityIRI, slims);
         }
     }
 
-    private OBOXref extractOBOXrefs (OWLAnnotation annotation) {
+    private OBOXref extractOBOXrefs(OWLAnnotation annotation) {
 
         OBOXref xref = new OBOXref();
         String xrefValue;
         if (annotation.getValue() instanceof IRI) {
             xrefValue = annotation.getValue().toString();
-        }
-        else {
-            xrefValue=getOWLAnnotationValueAsString(annotation.getValue()).get();
+        } else {
+            xrefValue = getOWLAnnotationValueAsString(annotation.getValue()).get();
         }
 
         String database = null;
@@ -1442,7 +1424,7 @@ private OBOXref extractOBOXrefs (OWLAnnotation annotation) {
         } else {
             if (xrefValue.contains(":") & xrefValue.split(":").length <= 2) {
                 database = xrefValue.substring(0, xrefValue.indexOf(":"));
-                id = xrefValue.substring(xrefValue.indexOf(":") + 1, xrefValue.length() );
+                id = xrefValue.substring(xrefValue.indexOf(":") + 1, xrefValue.length());
 
                 // check for Url
                 if (databaseService != null) {
@@ -1471,17 +1453,16 @@ private OBOXref extractOBOXrefs (OWLAnnotation annotation) {
         return xref;
     }
 
-    private Optional<String> getOWLAnnotationValueAsString (OWLAnnotationValue value) {
+    private Optional<String> getOWLAnnotationValueAsString(OWLAnnotationValue value) {
 
         if (value instanceof IRI) {
-            Optional<String> shortForm= extractShortForm((IRI) value);
-            if ( shortForm.isPresent() && !shortForm.get().isEmpty()) {
+            Optional<String> shortForm = extractShortForm((IRI) value);
+            if (shortForm.isPresent() && !shortForm.get().isEmpty()) {
                 return Optional.of(shortForm.get());
             } else {
-                return Optional.of( ((IRI) value).toString() );
+                return Optional.of(((IRI) value).toString());
             }
-        }
-        else if (value instanceof OWLLiteral) {
+        } else if (value instanceof OWLLiteral) {
             return Optional.of(((OWLLiteral) value).getLiteral());
         }
         return Optional.of("");
@@ -1489,6 +1470,7 @@ else if (value instanceof OWLLiteral) {
     }
 
     protected abstract OWLReasoner getOWLReasoner(OWLOntology ontology) throws OWLOntologyCreationException;
+
     protected abstract void discardReasoner(OWLOntology ontology) throws OWLOntologyCreationException;
 
     // bunch of getters and setters
@@ -1496,21 +1478,27 @@ else if (value instanceof OWLLiteral) {
     protected void setDirectParents(IRI termIRI, Set<IRI> parents) {
         this.directParentTerms.put(termIRI, parents);
     }
+
     protected void setDirectTypes(IRI termIRI, Set<IRI> parents) {
         this.directTypes.put(termIRI, parents);
     }
+
     protected void setAllParents(IRI termIRI, Set<IRI> allParents) {
         this.allParentTerms.put(termIRI, allParents);
     }
+
     protected void setDirectChildren(IRI termIRI, Set<IRI> children) {
         this.directChildTerms.put(termIRI, children);
     }
+
     protected void setAllChildren(IRI termIRI, Set<IRI> allChildren) {
         this.allChildTerms.put(termIRI, allChildren);
     }
+
     protected void setEquivalentTerms(IRI termIRI, Set<IRI> equivalent) {
         this.equivalentTerms.put(termIRI, equivalent);
     }
+
     protected void addLocalTerms(IRI termIRI) {
         this.localTerms.add(termIRI);
     }
@@ -1518,45 +1506,60 @@ protected void addLocalTerms(IRI termIRI) {
     protected void addRootsTerms(IRI termIRI) {
         this.rootTerms.add(termIRI);
     }
+
     protected void addObsoleteTerms(IRI termIRI) {
         this.obsoleteTerms.add(termIRI);
     }
+
     protected void setRelatedTerms(IRI termIRI, Map<IRI, Collection<IRI>> relatedTerms) {
         this.relatedTerms.put(termIRI, relatedTerms);
     }
+
     protected void setRelatedParentTerms(IRI termIRI, Map<IRI, Collection<IRI>> relatedTerms) {
         this.relatedParentTerms.put(termIRI, relatedTerms);
     }
+
     protected void setAllRelatedTerms(IRI termIRI, Map<IRI, Collection<IRI>> relatedTerms) {
         this.allRelatedTerms.put(termIRI, relatedTerms);
     }
+
     protected void setRelatedIndividuals(IRI termIRI, Map<IRI, Collection<IRI>> relatedTerms) {
         this.allRelatedIndividuals.put(termIRI, relatedTerms);
     }
+
     protected void setRelatedIndividualsToClasses(IRI termIRI, Map<IRI, Collection<IRI>> relatedTerms) {
         this.allRelatedIndividualsToClasses.put(termIRI, relatedTerms);
     }
+
     protected void setRelatedClassesToIndividual(IRI termIRI, Map<IRI, Collection<IRI>> relatedTerms) {
         this.allRelatedClassesToIndividuals.put(termIRI, relatedTerms);
     }
 
 
-    protected void setOboDefinitionCitation (IRI termIri, Collection<OBODefinitionCitation> definitionCitations) {
+    protected void setOboDefinitionCitation(IRI termIri, Collection<OBODefinitionCitation> definitionCitations) {
         this.oboDefinitionCitations.put(termIri, definitionCitations);
     }
-    protected void setOboXref (IRI termIri, Collection<OBOXref> xrefs) {
+
+    protected void setOboXref(IRI termIri, Collection<OBOXref> xrefs) {
         this.oboXrefs.put(termIri, xrefs);
     }
-    protected void setOboSynonym (IRI termIri, Collection<OBOSynonym> synonyms) {
+
+    protected void setOboSynonym(IRI termIri, Collection<OBOSynonym> synonyms) {
         this.oboSynonyms.put(termIri, synonyms);
     }
 
+    protected void setAnonymousTypeDescriptions(IRI termIRI, Set<String> relatedAnonymousTypeDescriptions) {
+        this.anonymousTypeExpressionsAsString.put(termIRI, relatedAnonymousTypeDescriptions);
+    }
+
     protected void setSuperClassDescriptions(IRI termIRI, Set<String> relatedSuperDescriptions) {
         this.superclassExpressionsAsString.put(termIRI, relatedSuperDescriptions);
     }
+
     protected void setEquivalentClassDescriptions(IRI termIRI, Set<String> relatedEquivalentDescriptions) {
         this.equivalentClassExpressionsAsString.put(termIRI, relatedEquivalentDescriptions);
     }
+
     public Collection<String> getBaseIRI() {
         return baseIRIs;
     }
@@ -1695,7 +1698,7 @@ public Map<IRI, Collection<IRI>> getDirectTypes() {
     @Override
     public Collection<IRI> getDirectParentTerms(IRI iri) {
         Collection<IRI> parentTerms = directParentTerms.get(iri);
-        if(parentTerms == null){
+        if (parentTerms == null) {
             return new ArrayList<IRI>();
         }
         return parentTerms;
@@ -1714,7 +1717,7 @@ public Map<IRI, Collection<IRI>> getDirectChildTerms() {
     @Override
     public Collection<IRI> getDirectChildTerms(IRI iri) {
         Collection<IRI> childTerms = directChildTerms.get(iri);
-        if(childTerms == null){
+        if (childTerms == null) {
             return new ArrayList<IRI>();
         }
         return directChildTerms.get(iri);
@@ -1735,6 +1738,11 @@ public Map<IRI, Collection<String>> getLogicalEquivalentClassDescriptions() {
         return this.equivalentClassExpressionsAsString;
     }
 
+    @Override
+    public Map<IRI, Collection<String>> getAnonymousTypes() {
+        return this.anonymousTypeExpressionsAsString;
+    }
+
     @Override
     public Map<IRI, Collection<IRI>> getEquivalentTerms() {
         return equivalentTerms;
@@ -1749,6 +1757,7 @@ public boolean isObsoleteTerm(IRI entityIRI) {
     public boolean isLocalTerm(IRI entityIRI) {
         return this.localTerms.contains(entityIRI);
     }
+
     public void setBaseIRI(Collection<String> baseIRIs) {
         this.baseIRIs = baseIRIs;
     }
@@ -1760,7 +1769,7 @@ public Collection<IRI> getAllClasses() {
 
     @Override
     public Collection<IRI> getAllObjectPropertyIRIs() {
-        return  lazyGet(() -> objectProperties);
+        return lazyGet(() -> objectProperties);
     }
 
     @Override
@@ -1815,10 +1824,11 @@ public void setOntologyName(String ontologyName) {
     }
 
 
-    public void setOntologyDescriptions(Map<String,String> descriptions) {
+    public void setOntologyDescriptions(Map<String, String> descriptions) {
         this.ontologyDescriptions = descriptions;
     }
-    public void setOntologyTitles(Map<String,String> titles) {
+
+    public void setOntologyTitles(Map<String, String> titles) {
         this.ontologyTitles = titles;
     }
 
@@ -1923,10 +1933,13 @@ public OWLDataFactory getFactory() {
         return factory;
     }
 
-    @Override public IRI getOntologyIRI() {
+    @Override
+    public IRI getOntologyIRI() {
         return ontologyIRI;
     }
-    @Override public IRI getOntologyVersionIRI() {
+
+    @Override
+    public IRI getOntologyVersionIRI() {
         return ontologyVersionIRI;
     }
 
@@ -1942,15 +1955,18 @@ public Map<IRI, String> getOntologyTermOboId() {
         return lazyGet(() -> oboIds);
     }
 
-    @Override public Map<IRI, LocalizedStrings> getTermLabels() {
+    @Override
+    public Map<IRI, LocalizedStrings> getTermLabels() {
         return lazyGet(() -> ontologyLabels);
     }
 
-    @Override public Map<IRI, LocalizedStrings> getTermSynonyms() {
+    @Override
+    public Map<IRI, LocalizedStrings> getTermSynonyms() {
         return lazyGet(() -> ontologySynonyms);
     }
 
-    @Override public Map<IRI, LocalizedStrings> getTermDefinitions() {
+    @Override
+    public Map<IRI, LocalizedStrings> getTermDefinitions() {
         return lazyGet(() -> ontologyDefinitions);
     }
 
@@ -2056,7 +2072,7 @@ public String getPreferredPrefix() {
         return preferredPrefix;
     }
 
-    public void setOntologyAnnotations(Map<String,Map<String,List<String>>> annotations) {
+    public void setOntologyAnnotations(Map<String, Map<String, List<String>>> annotations) {
         this.ontologyAnnotations = annotations;
     }
 
@@ -2092,12 +2108,12 @@ public String getVersionNumber() {
 
 
     @Override
-    public Map<String,String> getLocalizedTitles() {
+    public Map<String, String> getLocalizedTitles() {
         return ontologyTitles;
     }
 
     @Override
-    public Map<String,String> getLocalizedDescriptions() {
+    public Map<String, String> getLocalizedDescriptions() {
         return ontologyDescriptions;
     }
 
@@ -2140,14 +2156,14 @@ public void setPreferredLanguageMap(OWLAnnotationProperty property, List<String>
 
 
     public Collection<IRI> getPreferredRootTerms() {
-    	return preferredRootTerms;
+        return preferredRootTerms;
     }
 
     public void setPreferredRootTerms(Collection<IRI> preferredRootTerms) {
         this.preferredRootTerms = preferredRootTerms;
     }
 
-	public Set<String> getOntologyLanguages() {
-		return ontologyLanguages;
-	}
+    public Set<String> getOntologyLanguages() {
+        return ontologyLanguages;
+    }
 }
diff --git a/ontology-tools/src/main/java/uk/ac/ebi/spot/ols/loader/OntologyLoader.java b/ontology-tools/src/main/java/uk/ac/ebi/spot/ols/loader/OntologyLoader.java
index b530fe27..feb502ab 100644
--- a/ontology-tools/src/main/java/uk/ac/ebi/spot/ols/loader/OntologyLoader.java
+++ b/ontology-tools/src/main/java/uk/ac/ebi/spot/ols/loader/OntologyLoader.java
@@ -8,7 +8,6 @@
 
 import org.semanticweb.owlapi.model.IRI;
 import org.springframework.core.io.Resource;
-
 import uk.ac.ebi.spot.ols.util.LocalizedStrings;
 import uk.ac.ebi.spot.ols.util.OBODefinitionCitation;
 import uk.ac.ebi.spot.ols.util.OBOSynonym;
@@ -35,18 +34,21 @@ public interface OntologyLoader {
 
     /**
      * override where the ontology is loaded from
+     *
      * @param ontologyResource
      */
     void setOntologyResource(Resource ontologyResource);
 
     /**
      * override where the ontology imports are loaded from
+     *
      * @param ontologyImportMappings
      */
-     void setOntologyImportMappings(Map<IRI, IRI> ontologyImportMappings);
+    void setOntologyImportMappings(Map<IRI, IRI> ontologyImportMappings);
 
     /**
      * Get the IRIs of the property used to indicate a term or class definition
+     *
      * @return definitionProperty A collection of definition IRIs used in the ontology
      */
     Collection<IRI> getDefinitionIRIs();
@@ -85,13 +87,17 @@ public interface OntologyLoader {
 
 
     Collection<IRI> getAllClasses();
+
     Collection<IRI> getAllObjectPropertyIRIs();
+
     Collection<IRI> getAllDataPropertyIRIs();
+
     Collection<IRI> getAllIndividualIRIs();
+
     Collection<IRI> getAllAnnotationPropertyIRIs();
 
     /**
-     * Returns a mapping between the IRIs that identify classes in the loaded ontology and the 
+     * Returns a mapping between the IRIs that identify classes in the loaded ontology and the
      * corresponding class rdfs:label.
      *
      * @return the class labels in this ontology, indexed by class IRI and then language
@@ -137,72 +143,90 @@ public interface OntologyLoader {
 
     /**
      * Get a map of IRI definitions
+     *
      * @return definitionProperty A collection of definition IRIs used in the ontology
      */
     Map<IRI, LocalizedStrings> getTermDefinitions();
 
     Map<IRI, Collection<IRI>> getDirectParentTerms();
+
     Collection<IRI> getDirectParentTerms(IRI iri);
+
     Map<IRI, Collection<IRI>> getAllParentTerms();
 
     /**
      * Get direct type for owl individuals
+     *
      * @return
      */
     Map<IRI, Collection<IRI>> getDirectTypes();
 
-    Collection<String> getInternalMetadataProperties ();
+    Collection<String> getInternalMetadataProperties();
+
+    Map<String, String> getLocalizedTitles();
 
-    Map<String,String> getLocalizedTitles();
-    Map<String,String> getLocalizedDescriptions();
+    Map<String, String> getLocalizedDescriptions();
 
     /**
      * Get a map of the ontology annotation in the form Map<language, Map<key, List<value>>>
+     *
      * @return
      */
     Map<String, Map<String, List<String>>> getOntologyAnnotations();
 
     /**
      * Get the ontology homepage
+     *
      * @return
      */
     String getHomePage();
 
     /**
      * Get a mailing list associated with this ontology
+     *
      * @return
      */
     String getMailingList();
 
     /**
      * Get an issue tracker associated with this ontology
+     *
      * @return
      */
     String getTracker();
 
     /**
      * Get a logo associated with this ontology
+     *
      * @return
      */
     String getLogo();
 
     /**
      * Get a version number for the ontology
+     *
      * @return
      */
     String getVersionNumber();
+
     Collection<String> getCreators();
 
     Map<IRI, Collection<IRI>> getDirectChildTerms();
+
     Collection<IRI> getDirectChildTerms(IRI iri);
+
     Map<IRI, Collection<IRI>> getAllChildTerms();
 
     Map<IRI, Collection<String>> getLogicalSuperClassDescriptions();
+
     Map<IRI, Collection<String>> getLogicalEquivalentClassDescriptions();
 
+    Map<IRI, Collection<String>> getAnonymousTypes();
+
     Map<IRI, Collection<IRI>> getEquivalentTerms();
 
     boolean isObsoleteTerm(IRI entityIRI);
+
     boolean isLocalTerm(IRI entityIRI);
 
     /**
@@ -214,7 +238,7 @@ public interface OntologyLoader {
     Map<IRI, Collection<IRI>> getRelatedTerms(IRI entityIRI);
 
     /**
-     * Returns all related terms that can be considered parents. Any relations that are considered 
+     * Returns all related terms that can be considered parents. Any relations that are considered
      * hierarchical in nature (e.g. part-of, develops-from etc..). Excludes supeclass/is-a parents
      *
      * @return the relationship IRI and the set of related terms
@@ -222,8 +246,8 @@ public interface OntologyLoader {
     Map<IRI, Collection<IRI>> getRelatedParentTerms(IRI entityIRI);
 
     /**
-     * Returns all transitive related terms that can be considered parents. Any relations that are 
-     * considered hierarchical in nature (e.g. part-of, develops-from etc..). This includes super 
+     * Returns all transitive related terms that can be considered parents. Any relations that are
+     * considered hierarchical in nature (e.g. part-of, develops-from etc..). This includes super
      * classes.
      *
      * @return the relationship IRI and the set of related terms
@@ -232,7 +256,7 @@ public interface OntologyLoader {
 
 
     /**
-     * Returns all related terms that can be considered children. Any relations that are considered 
+     * Returns all related terms that can be considered children. Any relations that are considered
      * hierarchical in nature (e.g. part-of, develops-from etc..)
      *
      * @return the relationship IRI and the set of related terms
@@ -265,7 +289,7 @@ public interface OntologyLoader {
 
     /**
      * Returns the terms that the ontology designers deem to be the roots of their ontology.
-     * 
+     *
      * @return a list of terms that are considered to be the preferred roots of the ontology.
      */
     Collection<IRI> getPreferredRootTerms();