In query mode, check against semantically equivalent rewrites of equivalence axioms

Nobody has claimed this yet.

E.g. an ontology may have

* `A = B and R some C`
* `B = D and S some E`

the def for A can be rewritten/unfolded as

* `A = D and R some C and S some E`

it may be the case that only this latter form will match against a particular patterns that expects two slots (e.g. fixed D, R, S and slots for C and E). In some cases the reverse may be the useful one. It is valid to attempt all possible combinations. This should remain in some kind of subset of DL (there is an infinite number of equivalent DL expressions, but I believe the number of EL++ equivalents is bounded and sensible)

This kind of folding/unfolding may be generally useful elsewhere. For example an ontology author may want to rewrite equivalence axioms to conform to the canonical style of the DPs.

There is some code in owltools but it would be better rewritten in scala

* https://github.com/owlcollab/owltools/wiki/Annotation-Extension-Folding
* http://owlcollab.github.io/owltools/api//index.html?owltools/TBoxUnFoldingTool.html

prolog too...
https://blipkit.wordpress.com/2012/01/14/unfolding-t-boxes-in-go-using-popl/

Start by locating the Scala query-mode matching entry point and reviewing the linked owltools annotation-extension folding and TBox unfolding references. Define how equivalent EL++ rewrites are generated and bounded, then verify that patterns can match both the original and useful unfolded forms without leaving the intended subset of description logic.

Written by the indexing model from the issue text.