The development of first-order logic programming can be traced back to resolution theorem proving and further to the Skolem-Herbrand-Gödel Theorem, a fundamental theorem of first-order logic. This book proceeds by providing an extrapolation of this development to a higher-order setting. More precisely, it presents a largely theoretical foundation of a form of higher-order resolution, and combined functional and logic programming.

The Clausal Theory of Types is a higher-order logic for which the Skolem-Herbrand-Gödel Theorem and resolution can be generalized. It is a clausal extensional sub-logic of Church's formulation of the Simple Theory of Types which includes equality. It is “higher-order” in the sense that it allows quantification of variables of all types, embeddable predicates, representations of functions and predicates by λ-abstractions, and equations involving abstractions.

All of these features enable its Horn clause form to be a concise logic and functional programming language which has a sound and complete declarative and operational semantics. Clausal Theory of Types logic programs incorporate higher-order functional evaluation as an elementary operation through unification or conditional higher-order rewriting, higher-order relational proofs through backtrack search, and the separation of their declarative specifications.

This extrapolation entails largely self-contained discussions on the development of resolution and logic programming, the simply typed λ-calculus, higher-order logics and Henkin-Andrews general models, higher-order forms of term rewriting and equational unification, and higher-order versions of the Resolution Theorem and fixed point, model theoretic, and operational results in logic programming.

We present the Higher-Order Skolem-Herbrand-Gödel Theorem for the Clausal Theory of Types. This is a form of Church's formulation of the Simple Theory of Types [27]. The Theorem uses Henkin's Completeness Theorem [87] for validity in general models.

We begin by reviewing automations of higher-order logic, its syntax using the simply typed λ-calculus, and Henkin-Andrews general model semantics [5, 87]. We introduce higher-order analogues of Herbrand interpretations called λ-models. We then define the Clausal Theory of Types as a sub-logic of the Simple Theory of Types with equality, and show that a higher-order Skolem-Herbrand-Gödel Theorem holds for it.

The Theorem leads to a partial decision procedure for testing the validity of formulas. It can be automated by generalizing resolution.

Automating Higher-Order Logic

Simple Type Theory derives from the Ramified Theory of Types and was intended to formalize mathematical reasoning. Church [27] presented a λ-calculus formulation of simple type theory and used it to prove the deduction theorem, Peano's postulates for arithmetic, and a formalization of definition by primitive recursion.

More recent applications of logics which are based on this higher-order logic are in the areas of theorem proving, hardware verification, programming language design, automating Zermelo-Fränkel set theory, natural language processing, and program transformation.

The theorem prover TPS [9, 10, 136], uses Church's formulation of higher-order logic. The most recent version, called TPS3, uses expansion tree proofs [134], Huet's higher-order unification procedure [97], and tactics [78, 150].

Introduction

This thesis studies the problem of designing listing algorithms for families of combinatorial structures. In particular, it studies the problem of designing listing algorithms whose implementations do not use overwhelming quantities of computational resources. The computational resources that are considered are running time and storage space. Using standard terminology from complexity theory, we indicate that the time and space requirements of an algorithm are small by saying that the algorithm is “efficient”.

Section 1 of this chapter introduces our problem by defining the notion of a family of structures. It explains informally what we mean by a listing algorithm for a family of structures without discussing computational details. Section 1.2 motivates the study, describing three reasons that the problem deserves attention. Section 1.3 gives the phrase “listing algorithm” a precise meaning. In this section we specify a deterministic computational machine and a probabilistic machine. We discuss the process of implementing combinatorial listing algorithms on these machines. Section 1.4 establishes criteria which we will use to determine whether or not a given listing algorithm is efficient. The criteria will be sufficiently general that we will be able to change the computational machines that we consider (within a large class of “reasonable” machines) without changing the set of families of combinatorial structures that have efficient listing algorithms. Section 1.5 contains a synopsis of the thesis. Finally, section 1.6 contains some bibliographic remarks.

The two sections in this chapter contain work which is related to the work described in chapters 1–4. In section 5.1 we compare the computational difficulty of the listing problem with the difficulty of other computational problems involving combinatorial structures. In section 5.2 we consider a particular computational counting problem which is related to a listing problem described in chapter 4.

Comparing Listing with other Computational Problems

In this section we compare the listing problem with other computational problems involving combinatorial structures. The problems that we consider are described in [JVV 86]. For completeness, we provide a description of the problems here. Suppose that S is a family of combinatorial structures. We consider five computational problems associated with S. In each case the input is a parameter value p of S:

Problem 1 – The Existence Problem

Determine whether or not S(p) = Ø.

Problem 2 – The Construction Problem

If S(p) is non-empty then output a member of an equivalence class in S(p). Otherwise, halt without output.

Problem 3 – The Listing Problem

If S(p) is non-empty then output one representative from each equivalence class in S(p). Otherwise, halt without output.

Problem 4 – The Random Sampling Problem

If S(p) is non-empty then “randomly” choose an equivalence class in S(p) and output a member of that equivalence class. Otherwise, halt without output.

A semantics of logic programming can be derived from the Skolem-Herbrand-Gödel Theorem of the first-order predicate calculus.

We trace the developments which led to logic programming from automations of theorem proving which used this fundamental result, especially those based on the resolution principle. We also discuss some criteria by which logic programming can be considered to be a programming language, and some of its limitations.

This case study motivates our approach to higher-order logic programming: a higher-order Skolem-Herbrand-Gödel Theorem would give a basis for a more expressive logic programming language.

From Theorem Provers to Logic Programming

A main task of automated theorem provers is to find whether or not a formula An+1 is a logical consequence of a conjunction of formulas A1 Λ … Λ An. For first-order classical logic [28], this is a recursively undecidable problem in general [25, 26], however there are semi-decision procedures for testing the validity of a formula which will halt if the formula being tested is valid, but may not halt if the formula is not valid.

Automated theorem provers have been used to answer questions such as “Does there exist a finite semigroup which simultaneously admits a non-trivial antiautomorphism without admitting a non-trivial involution?” [202], to prove Cantor's Theorem [9] and others in set theory, and to verify the correctness of a microprocessor [33].

The Skolem-Herbrand-Gödel Theorem

A fundamental result used in some of these procedures is the Skolem-Herbrand-Gödel Theorem [125].

Chapter 2 described several general methods for listing combinatorial structures. In order to illustrate the methods we applied them to a few specific families of structures. In addition, we made some observations concerning the application of the methods to various classes of combinatorial families including graph properties and recursively listable families.

While the examples in chapter 2 involved particular combinatorial families, the focus of our attention was on the general listing methods. In this chapter we will shift the focus of our attention to applications. We will be interested in looking at the particular algorithms that we have developed in the course of this work and in finding out what we have learned about particular combinatorial families in the course of the work.

We start by considering a few results from chapter 2 which we will not pursue farther in this chapter. First, consider Uniform Reducer 2 which we described in subsection 2.1.2. In theorem 2 we proved that whenever Uniform Reducer 2 is combined with any efficient random sampling algorithm S-Sample for any simple family S it becomes a probabilistic polynomial delay listing algorithm for S. The listing algorithm has exponentially small failure probability. This theorem leads immediately to efficient probabilistic listing algorithms for a number of interesting families of structures since other people have developed random sampling algorithms for these families.

For example, let Sp be the family with the following definition.

We define and discuss higher-order unification with a built-in higher-order equational theory. It subsumes unification and matching of simply typed λ-terms at all orders, and we present the major forms and their complexities down to the first-order cases.

Other forms of unification, their properties or applications are discussed in surveys by Gallier [64], and Siekmann [175, 176], and in collections of papers [110, 111].

Higher-order equational unifiability uses a definition of higher-order rewriting which can also be used for proofs in higher-order equational logic. We give soundness and completeness results for higher-order equational unification procedures which enable us to define higher-order resolution for CTT formulas of all orders. These results link unification and general model semantics.

We show that pure third-order equational matching is undecidable by a reduction from Hilbert's Tenth Problem. We discuss the open problem of the decidability of higher-order matching. Several approaches for its solution are presented. We give a higher-order matching algorithm which is sound and terminating. We also present a class of decidable pure third-order matching problems based on the Schwichtenberg-Statman characterization of the λ-definable functions on the simply typed Church numerals, a class of decidable matching problems of arbitrary order, show that pure third-order matchability is NP-hard by a reduction from propositional satisfiability, discuss resolving the Plotkin-Statman Conjecture, and consider Zaionc's treatment of regular unification problems. All of these approaches suggest that the problem is decidable.