Theorema System Research Articles

Automated Theorem Proving in the Classroom

We report on several scenarios of using automated theorem proving software in university education. In particular, we focus on using the Theorema system in a software-enhanced logic-course for students in computer science or artificial intelligence. The purpose of using logic-software in our teaching is not to teach students the proper use of a particular piece of software. In contrast, we try to employ certain software in order to spark students' motivation and to support their understanding of logic principles they are supposed to understand after having passed the course. In a sense, we try to let the software act as a logic-tutor, the software is not an additional subject we teach.

Synthesis of sorting algorithms using multisets in Theorema

Using multisets, we develop novel techniques for mechanizing the proofs of the synthesis conjectures for list–sorting algorithms, and we demonstrate them in the Theorema system. We use the classical principle of extracting the algorithm as a set of rewrite rules based on the witnesses found in the proof of the synthesis conjecture produced from the specification of the desired function (input and output conditions). The proofs are in natural style, using standard rules, but most importantly domain specific inference rules and strategies. In particular the use of multisets allows us to develop powerful strategies for the synthesis of arbitrarily structured recursive algorithms by general Noetherian induction, as well as for the automatic generation of the specifications of all necessary auxiliary functions (insert, merge, split), whose synthesis is performed using the same method. The proof techniques are implemented in the Theorema system and generate 8 sorting algorithms and 19 auxiliary functions.

Proof–Based Synthesis of Sorting Algorithms Using Multisets in Theorema

Using multisets, we develop novel techniques for mechanizing the proofs of the synthesis conjectures for list-sorting algorithms, and we demonstrate them in the Theorema system. We use the classical principle of extracting the algorithm as a set of rewrite rules based on the witnesses found in the proof of the synthesis conjecture produced from the specification of the desired function (input and output conditions). The proofs are in natural style, using standard rules, but most importantly domain specific inference rules and strategies. In particular the use of multisets allows us to develop powerful strategies for the synthesis of arbitrarily structured recursive algorithms by general Noetherian induction, as well as for the automatic generation of the specifications of all necessary auxiliary functions (insert, merge, split), whose synthesis is performed using the same method.

Mechanical synthesis of sorting algorithms for binary trees by logic and combinatorial techniques

We develop logic and combinatorial methods for automating the generation of sorting algorithms for binary trees, starting from input-output specifications and producing conditional rewrite rules. The main approach consists in proving (constructively) the existence of an appropriate output from every input. The proof may fail if some necessary sub-algorithms are lacking. Then, their specifications are suggested and their synthesis is performed by the same principles.Our main goal is to avoid the possibly prohibitive cost of pure resolution proofs by using a natural-style proving in which domain-specific strategies and inference steps lead to a significant increase of efficiency. In addition to classical techniques for natural-style proving, we introduce novel ones (priority of certain types of assumptions, transformation of elementary goals into conditions, special criteria for decomposition of the goal and of the assumptions), as well as methods based on the properties of domain-specific relations and functions. In particular, we use combinatorial techniques in order to generate possible witnesses, which in certain cases lead to the discovery of new induction principles. From the proof, the algorithm is extracted by transforming inductive proof steps into recursions, and case-based proof steps into conditionals.The approach is demonstrated in parallel using the Theorema system, by developing the theory, implementing the prover, and performing the proofs of the necessary properties and synthesis conjectures. It is also validated in the Coq system, which allows to compare the facilities of the two systems from the point of view of our application.

Theorema 2.0: Computer-Assisted Natural-Style Mathematics

The Theorema project aims at the development of a computer assistant for the working mathematician. Support should be given throughout all phases of mathematical activity, from introducing new mathematical concepts by definitions or axioms, through first (computational) experiments, the formulation of theorems, their justification by an exact proof, the application of a theorem as an algorithm, until to the dissemination of the results in form of a mathematical publication, the build up of bigger libraries of certified mathematical content and the like. This ambitious project is exactly along the lines of the QED manifesto issued in 1994 (see e.g. http://www.cs.ru.nl/~freek/qed/qed.html) and it was initiated in the mid-1990s by Bruno Buchberger. The Theorema system is a computer implementation of the ideas behind the Theorema project. One focus lies on the natural style of system input (in form of definitions, theorems, algorithms, etc.), system output (mainly in form of mathematical proofs) and user interaction. Another focus is theory exploration, i.e. the development of large consistent mathematical theories in a formal frame, in contrast to just proving single isolated theorems. When using the Theorema system, a user should not have to follow a certain style of mathematics enforced by the system (e.g. basing all of mathematics on set theory or certain variants of type theory), rather should the system support the user in her preferred flavour of doing math. The new implementation of the system, which we refer to as Theorema 2.0, is open-source and available through GitHub.

Theorema 2.0: A Graphical User Interface for a Mathematical Assistant System

Theorema 2.0 stands for a re-design including a complete re-implementation of the Theorema system, which was originally designed, developed, and implemented by Bruno Buchberger and his Theorema group at RISC. In this paper, we present the first prototype of a graphical user interface (GUI) for the new system. It heavily relies on powerful interactive capabilities introduced in recent releases of the underlying Mathematica system, most importantly the possibility of having dynamic objects connected to interface elements like sliders, menus, check-boxes, radio-buttons and the like. All these features are fully integrated into the Mathematica programming environment and allow the implementation of a modern user interface.

An e-learning environment for elementary analysis

CreaComp is a project at the University of Linz, which aims at producing computer-supported interactive learning units for several mathematical topics at introductory university level. The units are available as Mathematica notebooks. For student experimentation we provide computational, graphical and reasoning tools as well. This paper focuses on the elementary analysis units. The computational and graphical tools of the CreaComp learning environment facilitate the exploration of new mathematical objects and their properties (e.g., boundedness, continuity, limits of real valued functions). Using the provided tools students should be able to collect empirical data systematically and come up with conjectures. A CreaComp component allows the formulation of precise conjectures and the investigatation of their validity. The Theorema system, which has been integrated into the CreaComp learning environment, provides full predicate logic with a user-friendly twodimensional syntax and a couple of automated reasoners that produce proofs in an easy-to-read and natural presentation. We demonstrate the learning situations and the provided tools through several examples.

Using Computer Algebra techniques for the specification, verification and synthesis of recursive programs

We describe an innovative method for proving total correctness of tail recursive programs having a specific structure, namely programs in which an auxiliary tail recursive function is driven by a main nonrecursive function, and only the specification of the main function is provided. The specification of the auxiliary function is obtained almost fully automatically by solving coupled linear recursive sequences with constant coefficients. The process is carried out by means of CA (Computer Algebra) and AC (Algorithmic Combinatorics) and is implemented in the Theorema system (using Mathematica). We demonstrate this method on an example involving polynomial expressions. Furthermore, we develop a method for synthesis of recursive programs for computing polynomial expressions of a fixed degree by means of “cheap” operations, e.g., additions, subtractions and multiplications. For a given polynomial expression, we define its recursive program in a schemewise manner. The correctness of the synthesized programs follows from the general correctness of the synthesis method, which is proven once for all, using the verification method presented in the first part of this paper.

An automated prover for Zermelo–Fraenkel set theory in Theorema

This paper presents some fundamental aspects of the design and the implementation of an automated prover for Zermelo–Fraenkel set theory within the Theorema system. The method applies the “Prove–Compute–Solve” paradigm as its major strategy for generating proofs in a natural style for statements involving constructs from set theory.

Logicographic symbols

The idea of logicographic symbols is to attach graphical drawings to predicate or function constants. The drawings symbolize the intuition behind the notion denoted by the constants. Without losing rigor, logicographic symbols can be used in formal statements with the effect of enhancing readability considerably. In this paper we describe the concept, the design, and the use of logicographic symbols in logic languages, notably in the Theorema system. The presentation will be based on examples that illustrate the various aspects of logicographic symbols.

Algorithm Synthesis by Lazy Thinking: Examples and Implementation in Theorema

Recently, we proposed a systematic method for top-down synthesis and verification of lemmata and algorithms called “lazy thinking method” as a part of systematic mathematical theory exploration (mathematical knowledge management). The lazy thinking method is characterized: •by using a library of theorem and algorithm schemes•and by using the information contained in failing attempts to prove the schematic theorem or the correctness theorem for the algorithm scheme for inventing lemmata or requirements for subalgorithms, respectively. In this paper, we give a couple of examples for algorithm synthesis using the lazy thinking paradigm. These examples illustrate how the synthesized algorithm depends on the algorithm scheme used. Also, we give details about the implementation of the lazy thinking algorithm synthesis method in the frame of the Theorema system. In this implementation, the synthesis of the example algorithms can be carried out completely automatically, i.e. without any user interaction.

Building Up Hierarchical Mathematical Domains Using Functors in TH∃OREM∀

The world of mathematical domains is structured hierarchically. There are elementary domains and there are well-known techniques how to build up new domains from existing ones. Which of the domains to view as the actual basis of the hierarchy is the freedom of the mathematician who wants to work with these domains and it depends of course on the intention of their use. The strength of the concept lies, however, in the fact that a new domain is constructed from given domains by well-defined rules, which do not depend on the actually given domains but only rely on certain properties that hold in the given domains, and the construction rules guarantee certain properties for the new domain then.In the Theorema system, B. Buchberger introduced the concept of functors to represent these domain construction rules. A functor can actually be viewed as a function that produces a new domain from given domains by describing, which objects and operations are available in the new domain, and by defining, how new objects can be constructed from known objects and how operations on the new objects can be carried out using known operations in the underlying domains. Following the general philosophy of the Theorema system, functors play a role both in proving and in computing. The domain description contained in the functor holds structural information, which can be used by a prover for the new domain in order to find an appropriate structure of proofs for formulae containing objects of the new domain. The domain definitions, on the other hand, contain rules, which can be used by an evaluator for executing computations involving objects of the new domain.In the sequel, we will demonstrate the facilities that are provided in Theorema to define functors, to build up a hierarchy of domains using functors, and to do computations in the constructed domains.