This paper describes a resolution based Description Logic reasoning system called DLog. DLog transforms Description Logic axioms into a Prolog program and uses the standard Prolog execution for efficiently answering instance retrieval queries. From the Description Logic point of view, DLog is an ABox reasoning engine for the full SHIQ language. The DLog approach makes it possible to store the individuals in a database instead of memory, which results in better scalability and helps using description logic ontologies directly on top of existing information sources. To appear in Theory and Practice of Logic Programming (TPLP).
The basic idea of KAON2 is to first transform a @math knowledge base into a skolemized first-order clausal form. However, instead of using direct clausification, first a structural transformation @cite_2 is applied on the @math axioms. This transformation eliminates the nested concept descriptions by introducing new concepts; the resulting set of first-order clauses is denoted by @math . In the next step, basic superposition @cite_18 , a refinement of first-order resolution, is applied to saturate @math . The resulting set of clauses is denoted by @math . Clauses @math are then transformed into a disjunctive datalog program @cite_32 entailing the same set of ground facts as the initial DL knowledge base. This program is executed using a disjunctive datalog engine written specifically for KAON2. In this approach, the saturated clauses may still contain (non-nested) function symbols which are eliminated by introducing a new constant @math , standing for @math , for each individual @math in the ABox. This effectively means that KAON2 has to read the of the ABox before attempting to answer any queries.
@cite_18 @cite_32 @cite_2
2082976889 1999997889
Abstract Deduction methods for first-order constrained clauses with equality are described within an abstract framework: constraint strategies , consisting of an inference system, a constraint inheritance strategy and redundancy criteria for clauses and inferences. We give simple conditions for such a constraint strategy to be complete (refutationally and in the sense of Knuth-Bendix-like completion). This allows to prove in a uniform way the completeness of several instantiations of the framework with concrete strategies. For example, strategies in which equality constraints are inherited are basic : no inferences are needed on subterms introduced by unifiers of previous inferences. Ordering constraints reduce the search space by inheriting the ordering restrictions of previous inferences and increase the expressive power of the logic. Most resolution theorem provers convert a theorem into clause form before attempting to find a proof. The conventional translation of a first-order formula into clause form often obscures the structure of the formula, and may increase the length of the formula by an exponential amount in the worst case. We present a non-standard clause form translation that preserves more of the structure of the formula than the conventional translation. This new translation also avoids the exponential increase in size which may occur with the standard translation. We show how this idea may be combined with the idea of replacing predicates by their definitions before converting to clause form. We give a method of lock resolution which is appropriate for the non-standard clause form translation, and which has yielded a spectacular reduction in search space and time for one example. These techniques should increase the attractiveness of resolution theorem provers for program verification applications, since the theorems that arise in program verification are often simple but tedious for humans to prove.