Grouping Individuals into Patterns

The OTTER project applies the concept of grouping individuals by patterns. Patterns are determined by an individual’s:

  • Classes
  • Object property domains
  • Object property ranges
  • Data properties

Each individual has one and only one pattern. Consequently, a single individual is therefore contained within only one pattern.

The concept applied was introduced in the IBM Research paper , “The Summary Abox: Cutting Ontologies Down to Size”, by Achille Fokoue, Aaron Kershenbaum, Li Ma, Edith Schonberg, Kavitha Srinivas. It’s available at and also published by Springer at:

This paper includes the following abstract:

Reasoning in descriptive logic (DL) ontologies is known to be intractable in the worst-case. This poses a serious problem for the use of DL-based ontologies such as OWL, because in practice, most ontologies have numerous assertions about individuals in the Abox. We propose a technique to make reasoning scalable for very large Aboxes in secondary storage. The technique operates by producing a dramatically reduced summary Abox for the original Abox. Reasoning on the original Abox is reduced in most cases to reasoning on this reduced summary Abox. We show that our techniques scale to consistency detection on ontologies with 6.5 million role assertions.

The following quote from this paper summarizes the reasoning behind the concept:

“Intuitively, the Abox contains many redundant assertions from the point of view of consistency checking that can be collapsed to create a reduced summary Abox.”

The OtterServer stores all individuals (Abox) within patterns. Queries using the OWL class expression are then resolved by determining which patterns satisfy each of the nodes in a query.

As an example, the following query:

EABusinessModel:Person and (EABusinessModel:hasUserID value “EA1”) and (EABusinessModel:inOrganization some (EABusinessModel:Organization or (EABusinessModel:hasOrgID some xsd:string)))

is parsed and the patterns that satisfy each expression are determined. In the following diagram, the two nodes of the OWL class expression are shown in blocks with their sub-expressions. Each sub-expression shows the patterns that satisfy the expression. Each pattern in this example begins with the letter “r” followed by a number.

As shown in the root node, the expression labeled “e0” performs the operation of intersection on the sub-expressions, “e1, e2, e6”, which results in only pattern “r58” meeting all of the constraints.

In the node having the object property of “inorganization”, the expression labeled “e3” performs the union of the patterns in “e4” and “e5”.

Since the OtterServer stores pattern information in memory, the determination of patterns that satisfy the query is very fast. The patterns are accessed to select the individuals from the patterns that satisfy the specifics of the class expression. For this example, the resulting individuals populate the nodes of the query:

Person1 has the user id of “EA1” and is in organization “OntoTech”.

Although this is a very basic example, more complex queries are simplified by having more nodes with sub-expressions, where the operations of intersect and union are performed on memory resident patterns rather than upon individuals.

By grouping individuals by patterns, as proposed by IBM, it provides for an efficient use of the OWL class expression as a query language for individuals.

How patterns of individuals are stored and updated by the OtterServer will be described in later posts.