<p>I'm not 100% sure that I fully understood the question, but from what I grasped I would face the situation in this way.</p>

<p>First of all I refer to Java because all the libraries I know are meant for this language. Secondly, I don't think that OWL on its own is able to satisfy your goal, given that it can represent rules and axioms, but it does not provide reasoning, that is, you need a reasoner, so you need to build a program that uses it, plus doing additional processing that I will sketch below:</p>

<p>1) You didn't mention it, but I guess you have an underlying ontology w.r.t. you need to prove your consequence relation (what you denote with symbol "->"). If the ontology is not explicit, maybe it can be extracted/composed from the textual expressions you mentioned in the question.</p>

<p>2) you need to use a library for ontology manipulation, I suggest <a href="http://owlapi.sourceforge.net/" rel="nofollow">OWL API</a> from Manchester University, it is very powerful and simple, in the tutorial under section "documentation" you have an overview of the main functionalities, including the use of reasoners (the example shows Hermit, but the principle holds for any other reasoner).</p>

<p>3) At this point you need to check if the ontology is consistent (otherwise anything can be derived, as it often happens with false premises)</p>

<p>4) You add the following axiom to the ontology (you build it directly in Java, no need to serialize back, you can let the reasoner work on the in-memory representation) and check for consistency: A \sqsubseteq B, that is, using the associated interpretation: A^I \subseteq B^I, so it is equivalent to A => B (they have the same truth table).</p>

<p>5) At this point you can add the axiom Match(A,B), where A and B are your class expressions and Match is a Role/Relation that relates all the class expressions for which the second is a consequence of the first.</p>

<p>6) After a number of repetitions of these steps you may want to serialize the result and store it, and this again can be achieved quite simply using OWL API from the in-memory representation.</p>

<p>For some basics about Description Logics (the logic underpinning OWL ontologies) you can refer to <a href="https://www.google.it/url?sa=t&amp;rct=j&amp;q=&amp;esrc=s&amp;source=web&amp;cd=2&amp;cad=rja&amp;ved=0CEkQFjAB&amp;url=http://arxiv.org/abs/1201.4089&amp;ei=2B_gUIfkDsb44QShnYGoDQ&amp;usg=AFQjCNGTx4GmGHf9d5gxqkcXZm4RCRsf5Q&amp;sig2=lJpe7hESs50JRBDaV5_7jQ&amp;bvm=bv.1355534169,d.bGE" rel="nofollow">A description logic Primer (2012), Horrocks et al.</a> and to <a href="http://www.aifb.kit.edu/images/1/19/DL-Intro.pdf" rel="nofollow">Foundations of Description Logics (2011), Rudolph</a>.</p>

<p>I'm not a logician or a DL expert, so please verify all the information I provided and feel free to correct me :)</p>
Checking logical implication relationships between OWL expressions?
<p>I have a simple question which I suspect has no simple answer. Essentially, I want to check whether it is true that one OWL expression (#B) follows on logically from another (#A) - in other words I want to ask: is it true that #A -> #B?</p>

<p>The reason for this is that I'm writing a matching algorithm for an application which matches structures in a knowledge based (represented by the #KnowledgeStructure class) to a structure which describes the needs of the current application state (#StateRequirement). Both structures have properties which have string values representing OWL expressions over the state of a third kind of structure (#Model). These are: #KnowledgeStructure.PostCondition which expresses how the knowledge structure being applied to #Model will transform #Model; and #StateRequirement.GoalCondition, which expresses the #Model state that the application aims to achieve. I want to see, therefore, if the #KnowledgeStructure will satisfy the #StateRequirement by checking that the #KnowledgeStructure.PostCondition produces the desired #StateRequiremment.GoalCondition. I could express this abstractly as: (#KnowledgeStructure.Postcondition => #StateRequirement.GoalCondition) => Match(#KnowledgeStructure, #StateRequirement). Less confusingly I could express this as: ((#A -> #B) -> Match(#A, #B)) where both #A and #B are valid OWL expressions.</p>

<p>In the general case I would like to be able to express the following rule: "If it is true that the expression #B follows from #A, then the expression Match(#A, #B) is also true".</p>

<p>Essentially, my question is this: how do I pose or realise such a rule in OWL? How do I test whether one expression follows from another expression? Also, are existing reasoners sufficiently powerful to determine the relation #A -> #B between two expressions if this relation is not explicitly stated?</p>