The suggestor is a set of non-standard reasoning queries that support knowledge exploration.

It uses a DL reasoner to present the ontology as an "existential tree".

For example, in the following small ontology

ObjectProperty(p)
ObjectProperty(q)
ObjectProperty(r)
ObjectProperty(s)

SubClassOf(C, SomeValueFrom(p, F))
SubClassOf(C, SomeValueFrom(p, F2))
SubClassOf(C, MinCardinality(1, q, G))
SubClassOf(C, not(SomeValueFrom(s, Thing)))

We could present these axioms as

• C has properties p and q
• C has values F and F2 for property p
• C has value G for property q
• C could have property r
• C cannot have property s

All queries can be made of arbitrary class expressions. Eg

• IntersectionOf(D, SomeValuesFrom(p, F)) has property p
• IntersectionOf(D, SomeValuesFrom(p, F)) could have property r
• IntersectionOf(D, SomeValuesFrom(p, F)) has value F for property p

We might use the suggestor for many applications. Some examples might be

• directing user creation of class definitions, class expressions or individuals, ensuring satisfiability and reducing redundancy.
• creation or display of a "frames-style" view of an ontology, treating properties as slots.

Sanctioning

What we can possibly say about a class is often too broad to be useful, so heuristics may be used to define subsets of what is possible, those things that are more "interesting". This is known as sanctioning in this framework.

In the suggestor, sanctioning is pluggable. This is to allow developers freedom to use various notions of "interesting" when performing knowledge exploration. Sanction rules are registered with a suggestor and are queried in turn. A sanction rule is a positive test. The suggestor continues to process rules until it finds one that returns true (sanctioned) or until no other rules exist (not sanctioned).

Several implementations of sanctioning rules exist. {@link org.coode.suggestor.api.PropertySanctionRule} and {@link org.coode.suggestor.api.FillerSanctionRule} can be implemented to add further behaviours.