Contents 1 Introduction 1 2 Model Building 3 2.1 First-Order Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2.2 Constructing Models for Logical Theories . . . . . . . . . . . . . . . . . . . . . . . 4 2.3 Inconsistent Theories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 3 Linguistic Applications 5 3.1 Information Seeking Dialogue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 3.2 Controlling a Mobile Robot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3.3 Question Answering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 4 Using Inference Tools 8 4.1 Automated Model Builders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 4.2 Automated Theorem Provers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 4.3 System Integration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10<F18.67

Abstract. We present GDPLL, a generalization of the DPLL procedure. It solves the satisfiability problem for decidable fragments of quantifierfree first-order logic. Sufficient conditions are identified for proving soundness, termination and completeness of GDPLL. We show how the original DPLL procedure is an instance. Subsequently the GDPLL instances for equality logic, and the logic of equality over infinite ground term algebras are presented. Based on this, we implemented a decision procedure for inductive datatypes. We provide some new benchmarks, in order to compare variants.

Bottom-up query answering procedures tend to explore a much larger search space than what is strictly needed. Top-down processing methods use the query to perform a more focused search which can result in more efficient query answering. Given a Disjunctive Deductive Database, DB, and a query Q, we establish a strong connection between model generation and clause derivability in two different representations of DB and Q. This allows us to use a bottomup procedure for evaluating Q against DB in a top-down fashion. The approach requires no extensive rewriting of the input theory and introduces no new predicates. Rather, it is based on a certain duality principle for interpreting logical connectives. The duality transformation is achieved by reversing the direction of implication arrows in the clauses representing both the theory and the negation of the query. The application of a generic bottom-up procedure to the transformed clause set results in top-down query answering. Under favorable conditions efficiency gains are substantial as shown by our preliminary testing. We give the logical meaning of the duality transformation and point to the conditions and sources of improved efficiency.

Abstract. In this paper we give an overview of results for modal logic which can be shown using techniques and methods from first-order logic and resolution. Because of the breadth of the area and the many applications we focus on the use of first-order resolution methods for modal logics. In addition to traditional propositional modal logics we consider more expressive PDL-like dynamic modal logics which are closely related to description logics. Without going into too much detail, we survey different ways of translating modal logics into first-order logic, we explore different ways of using first-order resolution theorem provers, and we discuss a variety of results which have been obtained in the setting of first-order resolution. 1

Abstract. The clause linking technique of Lee and Plaisted proves the unsatisfiability of a set of first-order clauses by generating a sufficiently large set of instances of these clauses that can be shown to be propositionally unsatisfiable. In recent years, this approach has been refined in several directions, leading to both tableau-based methods, such as the Disconnection Tableau Calculus, and saturation-based methods, such as Primal Partial Instantiation and Resolution-based Instance Generation. We investigate the relationship between these calculi and answer the question to what extent refutation or consistency proofs in one calculus can be simulated in another one. 1

Three recent applications of computerised reasoning in natural language processing are presented. The first is a text understanding system developed in the late 1990s, the second is a spoken-dialogue interface to a mobile robot and automated home, and the third is a system that determines textual entailment. In all of these applications, off-the-shelf tools for reasoning with first-order logic (theorem provers as well as model builders) are employed to assist in natural language understanding. This overview is not only an attempt to identify the added value of computerised reasoning in natural language understanding, but also to point out the limitations of the first-order inference techniques currently used in natural language processing.

Mathematical logicians had developed the art of formalizing declarative knowledge long before the advent of the computer age. But they were interested primarily in formalizing mathematics. Because of the important role of nonmathematical knowledge in AI, their emphasis was too narrow from the perspective of knowledge representation, their formal languages were not sufficiently expressive. On the other hand, most logicians were not concerned about the possibility of automated reasoning; from the perspective of knowledge representation, they were often too generous in the choice of syntactic constructs. In spite of these differences, classical mathematical logic has exerted significant influence on knowledge representation research, and it is appropriate to begin this handbook with a discussion of the relationship between these fields. The language of classical logic that is most widely used in the theory of knowledge representation is the language of first-order (predicate) formulas. These are the formulas that John McCarthy proposed to use for representing declarative knowledge in his advice taker paper [176], and Alan Robinson proposed to prove automatically using resolution [236]. Propositional logic is, of course, the most important subset of first-order logic; recent

Abstract Ground Logic with Equality (GL = ) is a subset of First-Order Logic (FOL) in which functions or quantifiers are excluded, but equality is preserved. We argue about GL = ’s unique position (in terms of expressiveness and ease of decidability) between FOL and Propositional Logic (PL). We aim to solve satisfiability (SAT) problems formulated in GL = by converting them into PL using a satisfiability-preserving conversion algorithms, and running a general SAT solver on the resulting PL Knowledge Base (KB). We introduce two conversion algorithms, with the latter utilizing the former as a subroutine, and prove their correctness- that is, that the translation preserves satisfiability. The main contribution of this work is in utilizing input fragmentation to yield PL KBs that are smaller than possible prior to our work, thus resulting in the ability to solve GL = SAT problems faster than was possible before. 1

We overview the development of first-order automated reasoning systems starting from their early years. Based on the analysis of current and potential applications of such systems, we also try to predict new trends in first-order automated reasoning. Our presentation will be centered around two main motives: efficiency and usefulness for existing and future potential applications. This paper expresses the views of the author on past, present, and future of theorem proving in first-order logic gained during ten years of working on the development, implementation, and applications of the theorem prover Vampire, see [Riazanov and Voronkov, 2002a]. It reflects our recent experience with applications of Vampire in verification, proof assistants, theorem proving, and semantic Web, as well as the analysis of future potential applications. 1 Theorem Proving in First-Order Logic The idea of automatic theorem proving has a long history both in mathematics and computer science. For a long time, it was believed by many that hard theorems in mathematics can be proved in a completely automatic way, using the ability of computers to perform fast combinatorial calculations. The very first experiments in automated theorem proving have shown that the purely combinatorial methods of proving firstorder theorems are too week even for proving theorems regarded as relatively easy by mathematicians. Provability in first-order logic is a very hard combinatorial problem. First-order logic is undecidable, which means that there is no terminating procedure checking provability of formulas. There are decidable classes of first-order formulas but formulas of these classes do not often arise in applications. Due to undecidability, very short formulas may turn out to be extremely complex, while very long ones rather easy. Sometimes first-order provers find proofs consisting of several thousand steps in a few seconds, but sometimes it takes hours to find a ten-step proof. The theory of first-order reasoning is centered around the completeness theorems while in practice completeness is often not an issue due to the intrinsic * Partially supported by a grant from EPSRC.

This is the first of three planned papers describing ZAP, a satisfiability engine that substantially generalizes existing tools while retaining the performance characteristics of modern high-performance solvers. The fundamental idea underlying ZAP is that many problems passed to such engines contain rich internal structure that is obscured by the Boolean representation used; our goal is to define a representation in which this structure is apparent and can easily be exploited to improve computational performance. This paper is a survey of the work underlying ZAP, and discusses previous attempts to improve the performance of the Davis-Putnam-Logemann-Loveland algorithm by exploiting the structure of the problem being solved. We examine existing ideas including extensions of the Boolean language to allow cardinality constraints, pseudo-Boolean representations, symmetry, and a limited form of quantification. While this paper is intended as a survey, our research results are contained in the two subsequent articles, with the theoretical structure of ZAP described in the second paper in this series, and ZAP's implementation described in the third.