Christoph Benzmüller

Omega: Towards a Mathematical Assistant

Ωmega is a mixed-initiative system with the ultimate purpose of supporting theorem proving in main-stream mathematics and mathematics education. The current system consists of a proof planner and an integrated collection of tools for formulating problems, proving subproblems, and proof presentation.

Proof Development with OMEGA

The Ωmega proof development system [2] is the core of several related and well integrated research projects of the Ωmega research group.

Automated Reasoning in Higher-Order Logic using the TPTP THF Infrastructure

The Thousands of Problems for Theorem Provers (TPTP) problem library is the basis of a well known and well established infrastructure that supports research, development, and deployment of Automated Theorem Proving (ATP) systems. The extension of the TPTP from first-order form (FOF) logic to typed higher-order form (THF) logic has provided a basis for new development and application of ATP systems for higher-order logic. Key developments have been the specification of the THF language, the addition of higher-order problems to the TPTP, the development of the TPTP THF infrastructure, several ATP systems for higher-order logic, and the use of higher-order ATP in a range of domains. This paper describes these developments.

System Description: LEO - A Higher-Order Theorem Prover

Many (mathematical) problems, such as Cantor’s theorem, can be expressed very elegantly in higher-order logic, but lead to an exhaustive and un-intuitive formulation when coded in first-order logic. Thus, despite the difficulty of higher-order automated theorem proving, which has to deal with problems like the undecidability of higher-order unification (HOU) and the need for primitive substitution, there are proof problems which lie beyond the capabilities of first-order theorem provers, but instead can be solved easily by an higher-order theorem prover (HOATP) like Leo .T his is due to the expressiveness of higher-order Logic and, in the special case of Leo, due to an appropriate handling of the extensionality principles (functional extensionality and extensionality on truth values). Leo uses a higher-order Logic based upon Church’s simply typed λ-calculus, so that the comprehension axioms are implicitly handled by αβη-equality. Leo employs a higher-order resolution calculus ERES (see [3] in this volume for details), where the search for empty clauses and higher-order pre-unification [6] are interleaved: the unifiability preconditions of the resolution and factoring rules are residuated as special negative equality literals that are treated by special unification rules. In contrast to other HOATP’s (such as Tps [1]) extensionality principles are build in into Leo’s unification, and hence do not have to be axiomatized in order to achieve Henkin completeness. Architecture

LEO-II - A Cooperative Automatic Theorem Prover for Classical Higher-Order Logic (System Description)

LEO-II is a standalone, resolution-based higher-order theorem prover designed for effective cooperation with specialist provers for natural fragments of higher-order logic. At present LEO-II can cooperate with the first-order automated theorem provers E, SPASS, and Vampire. The improved performance of LEO-II, especially in comparison to its predecessor LEO, is due to several novel features including the exploitation of term sharing and term indexing techniques, support for primitive equality reasoning, and improved heuristics at the calculus level. LEO-II is implemented in Objective Caml and its problem representation language is the new TPTP THF language.

Quantified Multimodal Logics in Simple Type Theory

We present an embedding of quantified multimodal logics into simple type theory and prove its soundness and completeness. A correspondence between QKπ models for quantified multimodal logics and Henkin models is established and exploited. Our embedding supports the application of off-the-shelf higher-order theorem provers for reasoning within and about quantified multimodal logics. Moreover, it provides a starting point for further logic embeddings and their combinations in simple type theory.

Computer supported mathematics with Ωmega

Classical automated theorem proving of today is based on ingenious search techniques to nd a proof for a given theorem in very large search spaces { often in the range of several billion clauses. But in spite of many successful attempts to prove even open mathematical problems automatically, their use in everyday mathematical practice is still limited. The shift from search based methods to more abstract planning techniques however opened up a paradigm for mathematical reasoning on a computer and several systems of that kind now employ a mix of interactive, search based as well as proof planning techniques. The mega system is at the core of several related and well-integrated research projects of the mega research group, whose aim is to develop system support for a working mathematician as well as a software engineer when employing formal methods for quality assurance. In particular, mega supports proof development at a human-oriented abstract level of proof granularity. It is a modular system with a central proof data structure and several supplementary subsystems including automated deduction and computer algebra systems. mega has many characteristics in common with systems like NuPrL, CoQ, Hol, Pvs, and Isabelle. However, it diers from these systems with respect to its focus on proof planning and in that respect it is more similar to the proof planning systems Clam and Clam at Edinburgh.

THF0 --- The Core of the TPTP Language for Higher-Order Logic

One of the keys to the success of the Thousands of Problems for Theorem Provers (TPTP) problem library and related infrastructure is the consistent use of the TPTP language. This paper introduces the core of the TPTP language for higher-order logic --- THF0, based on Churchs simple type theory. THF0 is a syntactically conservative extension of the untyped first-order TPTP language.

Proof Development with Ωmega: The Irrationality of \sqrt 2

The well-known theorem asserting the irrationality of \(\sqrt 2\) was proposed as a case study for a comparison of fifteen (interactive) theorem proving systems [Wiedijk, 2002]. This represents an important shift of emphasis in the field of automated deduction away from the somehow artificial problems of the past back to real mathematical challenges.

Combined reasoning by automated cooperation

Different reasoning systems have different strengths and weaknesses, and often it is useful to combine these systems to gain as much as possible from their strengths and retain as little as possible from their weaknesses. Of particular interest is the integration of first-order and higher-order techniques. First-order reasoning systems, on the one hand, have reached considerable strength in some niches, but in many areas of mathematics they still cannot reliably solve relatively simple problems, for example, when reasoning about sets, relations, or functions. Higher-order reasoning systems, on the other hand, can solve problems of this kind automatically. But the complexity inherent in their calculi prevents them from solving a whole range of problems. However, while many problems cannot be solved by any one system alone, they can be solved by a combination of these systems. We present a general agent-based methodology for integrating different reasoning systems. It provides a generic integration framework which facilitates the cooperation between diverse reasoners, but can also be refined to enable more efficient, specialist integrations. We empirically evaluate its usefulness, effectiveness and efficiency by case studies involving the integration of first-order and higher-order automated theorem provers, computer algebra systems, and model generators.