Lambda Logic

Michael Beeson ^{∗}

July 23, 2006

Abstract

Lambda logic is the union of first order logic and lambda calculus. The purpose of this note is to give a complete and precise definition of the syntax of lambda logic, and explain its relations to first order logic and to simple type theory. This is a revised and expanded version of [6].

1 Introduction

The twentieth century saw the flowering of first order logic, and the invention and development of the lambda calculus. When the lambda calculus was first developed, its creator (Alonzo Church) intended it as a foundational system, i.e., one in which mathematics could be developed and with the aid of which the foundations of mathematics could be studied. His first theories were inconsistent, just as the first set theories had been at the opening of the twentieth century. Modifications of these inconsistent theories never achieved the fame that modifications of the inconsistent set theories did. Instead, first order logic came to be the tool of choice for formalizing mathematics, and lambda calculus is now considered as one of several tools for analyzing the notion of algorithm.

The point of view underlying lambda logic is that lambda calculus is a good tool for representing the notion of function, not only the notion of computable function. First-order logic can treat functions by introducing function symbols for particular functions, but then there is no way to construct other functions by abstraction or recursion. Of course, one can consider set theory as a special case of first order logic, and define functions in set theory as univalent functions, but this requires building up a lot of formal machinery, and has other disadvantages as well. It is natural to consider combining lambda calculus with logic. That was done long ago in the case of typed logics; for example Gödel’s theory T had what amounted to the ability to define functions by lambda-abstraction. But typed lambda calculus lacks the full power of the untyped (ordinary) lambda calculus, as there is no fixed-point theorem to support arbitrary recursive definitions.

In this paper, we combine ordinary first order lambda calculus with ordinary first order logic to obtain systems we collectively refer to as lambda logic. We are not the first to define or study similar systems.^{1} The applicative theories proposed by Feferman in [7] are similar in concept. They are, however, different in some technical details that are important for the theorems proved here. Lambda logic is also related to the systems of illative combinatory logic studied in [2], [3], but these are stronger than lambda logic. As far as we know, the systems defined in this paper have not been studied before.

∗Research supported by NSF grant number CCR-0204362.

Both ordinary and lambda logic can be modified to allow “undefined terms”. In the context of ordinary logic this has been studied in [9], [5], [4]. In the context of applicative theories, [4] defined and studied “partial combinatory algebras”; but application in the λ-calculus is always total. Moggi [8] was apparently the first to publish a definition of partial lambda calculus; see [8] for a thorough discussion of different versions of partial lambda calculus and partial combinatory logic.

2 Syntax

As is usual in formalizing first-order logic, we suppose given an infinite list of variables. We also suppose given an infinite list of predicate symbols and an infinite list of function symbols. Unlike in first-order logic we require that every predicate symbol is also a function symbol. We do not require that the predicate and function symbols come with a prescribed arity (although semantically, if f occurs with different arities, the occurrences with different arities will be treated as if they were different symbols). We suppose given an infinite list of constant symbols, disjoint from the list of variables. The particular symbol lambda is not a function or predicate symbol, and the list of function symbols contains a distinguished element Ap.

If someone wishes a more precise specification of this basic apparatus, we could take the following completely precise definition:

digit:= 0-9.
variable:= [U-Z]digit* | [u-z]digit*.
constant:= [A-T]digit* | [a-t]digit* | true | false.
logicalSymbol := and | or | implies | neg | =.
functionSymbol:- Ap | [a-t]digit* | [A-T]digit* | logicalSymbol.
predicateSymbol:- Ap | [A-T]digit* | logicalSymbol.

Here is a grammar defining the syntax of lambda logic.

binder:= lambda | forall | exists.
functionTerm:= functionSymbol(term {,term}*).
term:= variable | constant | functionTerm | binder(variable, term).
atomicFormula:= predicateSymbol(term {, term}*) | true | false.
formula:= atomicFormula | compoundFormula.

1For example, John McCarthy told me that he lectured on such systems years ago, but never published anything.

compoundFormula:-  connective(formula,formula) |
                   neg(formula) |
                   quantifier(variable,formula).
connective:- and, or, implies.
quantifier:- forall | exists.

Note that because predicate symbols are also function symbols (here just called “symbols”), and true and false are constants, every formula is also a term. Thus, for example, lambda(x, x + y = y + x) is a term, since x + y = y + x is a term, since = is a function symbol. Hence Ap(lambda(x, x + y = y + x), z) is a formula, since Ap is a predicate symbol and lambda(x, x + y = y + x) is a term. There will also be formulas that would not occur in first-order logic, such as f(forall(x, a)) = b (where a and b are constants).

On the other hand, not every term is a formula. For example, a variable is not a formula. Note that for c a constant, Ap(lambda(x, t), c) is a formula, since Ap is a symbol and λ(x, t) is a term. As a term, this expression β-reduces to t, but that does not make t a formula. Indeed, when we get to the axioms, we will see that β-reduction applies to formulas, but only if both sides are formulas. Another difference between terms and formulas is that lambda terms do not count as formulas. In other words, we do not allow predicate abstraction, for example forming a new predicate λx.P (x, y) from the predicate P. This can be done indirectly in case P has a characteristic function, but is not allowed in general.

As is customary in logic textbooks, we regard infix notation as an abbreviation at the meta-level, so that (x + y) really means +(x, y). Similarly A ∧ B is really ∧(A, B). T is regarded as a syntactic variant of true. That means that ‘T’ and true are two different names for the same symbol. Similarly, F is a syntactic variant of false. The term lambda(x, t) can also be written as λx. t; the latter notation is just an informal abbreviation for the offical notation lambda(x, t). The notations ∀x A and (∀x) A are meta-level abbreviations for forall(x, A), and similarly for ∃. The symbols ∧,∨, →, and ¬ are syntactic variants of and, or, implies, and neg, respectively. Other typographically convenient symbols, such as < or ≤, can similarly be regarded as meta-level abbreviations for certain legal predicate symbols.

Each formula has two representations: as a string and as a labeled tree. One and only one tree representation corresponds to each string representation, and vice-versa. An occurrence of a variable in a formula is represented by a single leaf node in the tree representation. In that case there is a unique path from that node to the root of the tree representation. The binding operators are ∀, ∃, and λ. An occurrence of binding operator in a term or formula has a variable as its first argument (child in the tree). The concepts that a certain occurrence of a variable in a term or formula A is free in A or bound in A, and the concept that an occurrence of a binding operator binds certain occurrences of variables, are defined mutually by recursion as follows. “Bound” is a synonym for “not free”.

In a formula ∀x A, this occurrence of ∀ binds all occurrences of x that are free in A. Those occurrences of x are bound in ∀x A. In a formula ∃x A, this occurrence of ∃ binds all occurrences of x that are free in A. Those occurrences of x are bound in ∃x A. In a term lambda(x, t), this occurrence of lambda binds all occurrences of x that are free in t. Those occurrences of x are bound in lambda(x, t). Occurrences of variables in compound terms and formulas constructed by the syntax rules not involving binding operators retain the free or bound status that they had in the component formulas. Note that the same variable can have both free occurrences and bound occurrences in a given formula.

Renaming bound variables. If z is a variable that does not occur in ∀x A, then the formula obtained by replacing all occurrences of x that are bound by this binding operator by z is said to be α-convertible to ∀x A; similarly for ∃x A and lambda(x, t). The relation of α-equivalence is the least reflexive and transitive relation containing α-convertibility and satisfying in addition the conditions that

(i) if t is α-equivalent to s then f(t) is α-equivalent to f(s), and similarly f(r, t) is α-equivalent to f(r, s), and similarly for each argument position of a term of any arity.

(ii) if t is α-equivalent to s then lambda(x, t) is α-equivalent to lambda(x, s). If x is any variable, and A is any term or formula, then we can find a term or

formula B such that B is α-equivalent to A and B does not contain any bound occurrences of x. We say such a B is “free for x”. Specifically, an algorithm freeF or(A, x) is defined by recursion on the term-or-formula A. The crucial clause is when the main symbol of A is a binding operator and the variable it binds is x. In that case, the algorithm is called recursively on the second argument of the term-or-formula and then, (i) a “fresh” variable y is chosen (the lexicographically least one beginning with the same letter as x and not occurring in the result of the recursive call), and then (ii) each occurrence of x bound by this occurrence of the binding operator is replaced by y.

Substitution. By A[x := t] we mean the result of the following algorithm: Initialize P to A. Then for each variable z having at least one free occurrence in t, replace P by freeF or(P, z). The final value of P has no bound occurrences of any variables free in t, and is α-equivalent to A. Then replace each free occurrence of x in P by t. That is the value of A[x := t]. In other words, we first rename bound variables in A to avoid capture of the free variables of t, and then replace x by t in A.

β reduction. The term Ap(lambda(x, t), q) is said to β-reduce immediately to t[x := q]. The relation “t β-reduces to s” is defined as the least reflexive and transitive relation containing immediate β-reduction and satisfying:

(i) if t β-reduces to s then f(t) reduces to f(s), and similarly f(r, t) reduces to f(r, s), and similarly for each argument position of a term of any arity.

(ii) if t β-reduces to s then lambda(x, t) β-reduces to lambda(x, s). Example: in first order logic we can formulate the theory of groups, using a constant e for the identity, and function symbols for the group operation and inverse. The use of infix notation x · y can either be regarded as official or as an informal abbreviation for m(x, y), just as it can in first order logic. If we formulate the same theory in lambda logic, we use a unary predicate G for the group, and relativize the group axioms to that predicate, just as we would do in first order logic if we needed to study a group and a subgroup. Then in lambda logic we can define the commutator c := λx, y.((i(x) · i(y)) · x) · y, and derive the following:

G(x) ∧ G(y) → c(x, y) = ((i(x) · i(y)) · x) · y

The hypothesis G(x) ∧ G(y) is needed because we relativized the group axioms to G. We want to formulate the theory of groups, not the theory of models of the lambda calculus that can be turned into groups. Alternately, we can replace G(x) by Ap(G, x) = T, and x · y by Ap(Ap(·, x), y).

If we want to discuss more than one group at a time, then instead of using a constant e for the identity, we can a variable; and we can even use a variable for the group operation (although then we can no longer write x·y in infix notation; we must write Ap(Ap(o, x), y). Unofficially we could abbreviate that as (xoy) for readability in the context of group theory.

That formulation allows us to discuss subgroups, homomorphisms, etc. quite naturally.

Specifically, a homomorphism from a group (G, e, ×) to (H, 1, +), where here × and + are variables being used for the two group operations, would be an object u such that

Ap(G, x) → (H(Ap(u, x))
Ap(G, x) ∧ Ap(G, y) → Ap(u, x) + Ap(u, y) = Ap(u, x · y)

Now one can quantify over homomorphisms, for example to state that a homomorphism from G to H is one-to-one if and only if its kernel is the identity.

Note that we could also have used two predicate symbols G and H instead of variables. Then we would have written G(x) instead of Ap(G, x). These are not the same. Using predicate symbols, we would not be able to quantify over groups.

Example: Peano’s axioms. Peano’s axioms for number theory say that the natural numbers N constitute the least set containing 0 and closed under successor, where successor is a one-to-one function from N to N that takes every value except 0. It is common to consider the recursive definitions of addition and multiplication as part of Peano’s axioms, too. An equivalent formulation is that mathematical induction holds for all sets X of integers: if 0 ∈ X and ∀n(n ∈ X → s(n) ∈ X) then ∀n(n ∈ X). The first-order theory PA is obtained by taking the induction schema, in which n ∈ X is replaced by any first-order formula ϕ(n). In lambda logic we can replace n ∈ X by Ap(X, n) = T, where X is a variable. Specifically, the induction schema in lambda logic is

Ap(X, 0) ∧ ∀x (N(x) ∧ Ap(X, x) → Ap(X, s(x))) → ∀z (N(x) → Ap(X, z)).

Here N is a unary predicate symbol; the other Peano axioms would be relativized to N. In making proofs by induction, we would want to instantiate X to a term such as λ(z, x + z = z + x). To construct such a term, we use the grammar rule

term := formula.

This is somewhat analogous to a “weak second-order theory” in which there are two sorts of first-order variables. The proof-theoretic strength of such theories depends on what comprehension axioms are included to allow the definition of sets to use in inductive proofs. The same presumably is true in lambda logic; without axioms even to define the characteristic functions of arithmetic predicates, this form of Peano’s axioms will be weak, probably only as strong as Π_{0}^{0} induction in the language of PA.

3 Axioms and inference rules

Lambda logic can be formulated using any of the usual approaches to predicate calculus. We distinguish the sequent-calculus formulation, the Hilbertstyle formulation, and the resolution formulation. For definiteness we choose the Hilbert-style formulation as the definition (say as formulated in [10], p. 20), for the standard version.

(Prop) propositional axioms (see [10], p. 20)

(Q) standard quantifier axioms and rules (see [10], p. 20)

(α) t = s if t and s are alpha-equivalent terms.

(α) A → B if A and B are alpha-equivalent formulas.

(β) Ap(λx. t, s) = t[x := s] where t is any term.

(β) Ap(λx. A, s) ↔ A[x := s] where A is any formula.

(ξ) (weak extensionality) ∀x(Ap(t, x) = Ap(s, x)) → λx. Ap(t, x) = λx. Ap(s, x)

(true and false) T = λxλy. x and F = λxλy. y

(non-triviality) T ≠ F

4 Semantics

There is a standard definition of λ-model that is used in the semantics of the lambda calculus (see [1], p. 86, with details on p. 93). There is also a wellknown notion of a model of a first order theory. In this section our goal is to define the concept M is a model of the theory T in lambda logic in such a way that it will imply that, neglecting λ, M is a first order model of T, and also, neglecting the function symbols other than Ap, M is a λ-model.

The cited definition of λ-model involves the notion of terms, which we shall call M-terms, built up from Ap and constants c_{a} for each element a of the model. It requires the existence, for each term t of this kind, and each variable x, of another M-term λ^{∗}(x, t) such that M will satisfy

Ap(λ^{∗}(x, t), x) = t.

Note that this does not yet make sense, as we must first define the notion of “the interpretation of a term t in M”. We cannot simply refer to [1] for the definition, since we need to extend this definition to the situation in which we have a theory T with more function symbols than just Ap, although the required generalization is not difficult.

We first define a λ-structure. As usual in first order logic we sometimes use “M” to denote the carrier set of the structure M; and we use f_{M} or f̄ for the function in the structure M that serves as the interpretation of the function symbol f, but we sometimes omit the bar if confusion is unlikely. (M, λ∗) is a λ-structure for T if (1) M is a structure with a signature containing all the function symbols and constants occurring in T, and another binary function Ap_{M} to serve as the interpretation of Ap, and (2) there is an operation λ^{∗} on pairs (x, t), where t is an M-term and x is a variable, producing an element λ^{∗}(x, t) of M.

If (M, λ^{∗}) is a λ-structure for T, then by a valuation we mean a map g from the set of variables to (the carrier set of) M. If g is a valuation, and v = v_{1}, …, v_{n} is a list (vector) of variables, then by g(v) we mean g(v_{1}), …, g(v_{n}). If t is a term, then by t[v := g(v)] we mean the M-term resulting from replacing each variable v_{i} by the constant c_{g(v_{i})} for the element g(v_{i}) of M. If g is a valuation, then we can then extend g to the set of terms by defining

g[f(t_{1}, …, t_{n})] = f̄(g(t_{1}), …, g(t_{n}))
g[λx.t] = λ^{∗}(x, t[v := g(v)])

Now we have made sense of the notion “the interpretation of term t under valuation g”. If ϕ is a formula, we recursively define M ⊧_{g} ϕ as follows:

M ⊧_{g} ∀x A iff M ⊧_{h} A whenever h extends g and is defined on x
M ⊧_{g} ∃x A iff M ⊧_{h} A for some h that extends g and is defined on x
M ⊧_{g} ¬A iff it is not the case that M ⊧_{g} A
M ⊧_{g} A ∧ B iff M ⊧_{g} A and M ⊧_{g} B
M ⊧_{g} A ∨ B iff M ⊧_{g} A or M ⊧_{g} B
M ⊧_{g} t = s iff g(t) and g(s) are the same element of M
M ⊧_{g} P (t_{1}, …, t_{n}) iff P_{M}(g(t_{1}, …, g(t_{n})) where P is not Ap
M ⊧_{g} Ap(lambda(x, B), t) iff B is a formula and M ⊧ B[x := t]
M ⊧_{g} Ap(t, s) iff Ap_{M}(g(t), g(s)) when the previous clause does not apply

Note that in all cases except the next to last one, the complexity of the formula has clearly decreased. The question may arise whether the last clause is well-founded. We now prove it is. Let the “skeleton” of a formula A be the term obtained by replacing each atomic subformula by a constant c. By induction on the complexity of A, the skeleton of every formula A has a normal form. The clause defining M ⊧_{g} Ap(lambda(x, B), t) reduces the length of the outermost reduction of the skeleton of A. The other clauses reduce the complexity without increasing the length of the outermost reduction. Hence the definition of satisfaction can be regarded as a definition by induction on the pair (length of outermost reduction of the skeleton of A, complexity of A).

We define M ⊧ A if for all valuations g, M ⊧_{g} A. Note that for formulae not involving λ, the definition agrees with the usual definition of satisfaction in first order logic.

We are now in a position to define λ-model. This definition coincides with that in [1] in case T has no other function symbols than Ap.

Definition 1 (λ-model) (M, λ^{∗}) is a λ-model of a theory T in lambda logic if (M, λ^{∗}) satisfies the axioms α, β, and ξ, and M satisfies the axioms of T.

5 Consistency of lambda logic

Define the relation t ≡ s on terms of T to mean that t and s have a common reduct (using β and α reductions). The Church-Rosser theorem for λ calculus ([1], p. 62) implies that this is an equivalence relation, when the language includes only Ap and λ. The following theorem says that adding additional function symbols does not destroy the Church-Rosser property.

Theorem 1 The Church-Rosser theorem is valid for lambda logic.

Proof. For each function symbol f we introduce a constant f̄. We can then eliminate f in favor of f̄ as follows. For each term t we define the term t^{∘} as follows:

x^{∘} = x  for variables x
c^{∘} = c  for variables c
f(t)^{∘} = Ap(f̄, t^{∘})
f(t, r)^{∘} = Ap(Ap(f̄, t^{∘}), r^{∘}))
Ap(t, r)^{∘} = Ap(t^{∘}, r^{∘})
(λx. t)^{∘} = λx. t^{∘}

and similarly for functions of more than two arguments. Since there are no reduction rules involving the new constants, t reduces to q if and only if t^{∘} reduces to q^{∘}. Moreover, if t^{∘} reduces to v, then v has the form u^{∘} for some u. (Both assertions are proved by induction on the length of the reduction.) Suppose t reduces to q and also to r. Then t^{∘} reduces to q^{∘} and to r^{∘}. By the Church-Rosser theorem, q^{∘} and r^{∘} have a common reduct v, and v is u^{∘} for some u, so q and r both reduce to u. That completes the proof.

Theorem 2 Lambda logic is consistent, i.e. does not derive T = F.

Proof. We define a model (M, Ap_{M}) for lambda logic. The elements of M are the equivalence classes [t] of terms t under the relation t ≡ s defined above. We define Ap_{M}([t], [s]) := [Ap(t, s)].

One proves that, for valuations g with values in M, and x in the domain of g, and r any term in the equivalence class g(x), we have

M ⊧_{g} A if and only if M ⊧ A[x := r].  (1)

The β axiom for terms is satisfied since [Ap(lambda(x, t), r)] is [t[x := r]]. The β axiom for formulas is automatically satisfied by the definition of M ⊧ A. The axiom T ≠ F is satisfied since T and F are distinct normal terms.

The weak extensionality axiom (ξ) is satisfied, as follows: Suppose M satisfies ∀x (Ap(t, x) = Ap(s, x)). Let g be the valuation assigning x the value [x]. Then by (1), M satisfies Ap(t, x) = Ap(s, x). Hence M also satisfies lambda(x, Ap(t, x)) = lambda(x, Ap(s, x)), the conclusion of (ξ). That completes the proof.

6 Some consequences of the fixed point theorem

The fixed point theorem of lambda calculus says that for every F, there is an Ω such that F Ω = Ω. Namely, we can take Ω = Ap(ω, ω), where ω = lambda(x, Ap(F, Ap(x, x)). Another form of the fixed point theorem says that for every term H, we can find a term f such that Ap(f, x) = H(f, x). (To prove this, apply the first theorem with F = λx. H(f, x), and take f to be the Ω produced by the first theorem.)

Russell’s paradox as a fixed point. Since every F has a fixed point, there cannot be (in lambda calculus or in lambda logic) any term not such that for all x, not(x) ≠ x. This is the essence of Russell’s paradox: Suppose there was such a . If, following Church, we identify x ∈ y with Ap(y, x) = T, then following the proof of the fixed-point theorem we would set ω = λx. Ap(not, Ap(x, x)), which we recognize as the Russell set R = {x : x ∉ x}, since ω(x) = T if and only if Ap(x, x) ≠ T. Then considering the value of Ω = Ap(ω, ω) amounts to Russell’s famous question whether R ∈ R or not, and the fixed-point argument shows (Ω) = Ω, which in Russell’s terms says R ∈ R if and only if R ∉ R. Of course in lambda logic, this is not a paradox, since no such term e̸xists. Although one may find it counterintuitive that no such term exists, this is not new with lambda logic, but is a feature of lambda calculus known for over seventy years now.

Inconsistency of AC. Consider the following version of the axiom of choice: (AC) (Axiom of Choice) ∀x ∃y P (x, y) → ∃f ∀x P (x, Ap(f, x)).

AC is inconsistent with lambda logic: Simply take P (x, y) to be x ≠ y. Then by the non-triviality axiom of lambda logic, we can prove ∀x∃y x ≠ y (take y to be T if x ≠ T, and F if x = T). But then any choice function f would satisfy the equation for not, and hence there is no such f.

In [6], the last theorem is only vacuously true, since its conclusion says that something is provable in lambda logic plus AC.

Failure of Skolemization. The same example shows that Skolemization does not work in lambda logic. That is, in first order logic, ∀x ∃y A(x, y) is satisfiable if and only if ∀x A(x, f(x)) is satisfiable. But if we take x ≠ y for A(x, y), the former is satisfiable in lambda logic, but the latter is not, since then λx f(x) must have a fixed point. We show in the next section that this is not a serious problem–we just have to not allow lambda-abstraction when it would capture free variables in Skolem terms. That extended version of lambda logic can be used to prove a completeness theorem.

An example in group theory. Here is a more mathematical example using the fixed point theorem. Consider the theory in which we have a binary function · (written in infix notation), a constant e, and the axioms saying that · is a group operation identity e. Take H(f, x) = c · Ap(f, x), where c is anything. Applying the second form of the fixed point theorem we get Ap(f, x) = c · Ap(f, x). It follows from the axioms of group theory that c is the group identity. Since c was anything, we could have taken c to be T or F, but this implies T = F, contradicting the non-triviality axiom of lambda logic. This theory is inconsistent.

Looked at semantically, this is not a surprising result: it only means that it is impossible, given a lambda model M, to define a binary operation on M and an identity element of M that make M into a group. If we use a unary predicate G, and put in axioms saying that · is a group operation on G with identity e, then the above argument only shows that Ap(f, x) is not in G, i.e. ¬G(Ap(f, x)).

Extensionality. The following additional formula is sometimes added to lambda calculus.

(η) (extensionality) λx. Ap(t, x) = t.

It is not an axiom of lambda logic. It is, however, consistent with lambda logic since in the consistency proof in the previous section, we could have used η-reduction as well as β-reduction, appealing to the Church-Rosser theorem for η-reduction in lambda calculus.

Terms and formulas. Suppose we have deduced ¬A for some formula A. The rules of lambda logic do not allow us to deduce A = F as a term. Similarly, just because we have proved A does not entitle us to deduce A = T. Indeed, making A equivalent to A = T and ¬A equivalent to A = F would lead to contradictions. Freek Wiedijk gave the following example: let A be Ap(λw λx λy. T, w). Then A is a formula, so we have A ∨ ¬A. If we were able to deduce from this, A = T ∨ A = F, we could obtain a contradiction, as follows: As a term, A reduces to λx λy. T. Hence λx λy. T = T∨λx λy. T = F. But each disjunct can be refuted, since Ap(Ap(T, F), F) = F and Ap(Ap(F, F), F) = F according to the lambda-calculus definitions of T and F, but Ap(Ap(λx λy. T, F), F) = T, and one of the axioms of lambda logic is T ≠ F.

Note that λx λy. T is not a formula, so we are not able to β-reduce A as a formula, and the contradiction cannot be carried out in lambda logic. A formula only β-reduces if it reduces to another formula.

7 Completeness of lambda logic

The following theorem is to lambda logic as Gödel’s completeness theorem is to first order logic. As in first order logic, a theory T in lambda logic is called consistent if it does not derive any contradiction. In this section, we will prove the lambda completeness theorem: any consistent theory has a λ-model. First, we need some preliminaries.

Theorem 3 (Lambda Completeness Theorem) Let T be a consistent theory in lambda logic. Then T has a λ-model.

Remark. There is a known “first order equivalent” of the notion of λ-model, namely Scott domain. See [1](section 5.4). However, we could not use Scott domains to reduce the lambda completeness theorem to Gödel’s first order completeness theorem, because there is no syntactic interpretation of the theory of Scott domains in lambda logic. Proof of the completeness theorem. Our plan is to imitate the usual proof (Henkin’s method) of the completeness theorem, as set out for example in [10] pp. 43-48, can be imitated for lambda logic. However, the first step in the classical proof is Skolemization, which we have seen is problematic in lambda logic. The reason why it is problematic is that lambda logic permits lambda abstraction to be used on any function symbol, so for example we cannot construct a model with a Skolem function for ∀x∃y x ≠ y. The remedy is to enlarge lambda logic to allow “Skolem function symbols” with a restriction on their use in lambda terms. This enlarged logic presumes a list of “Skolem symbols” disjoint from the list of function symbols of lambda logic. A “Skolem term” is a term whose main symbol is a Skolem symbol. The restriction is that the term lambda(x,t) can only be formed when t does not contain a Skolem term with x free. Otherwise Skolem symbols are used just like ordinary function symbols and constants in forming terms.

Example. If f(x) is a Skolem term with the associated axiom f(x) ≠ x, then we cannot form λ(x, f(x)) (so we cannot derive a contradiction from the existence of a fixed point of that term).

The axioms of Skolem lambda logic are the same as those of lambda logic, except (of course) that in the (β) and (ξ) axiom schemata, only those instances are taken that are legal formulas in Skolem lambda logic.

We refer to this more elaborate system as “Skolem lambda logic”. We will use it only in the proof of the completeness theorem. The semantics of Skolem lambda logic generalizes the semantics of lambda logic defined above, by interpreting the Skolem terms as they would be interpreted in first order logic. That is, the model must specify a function f̄ from M to M to serve as the interpretation of each Skolem function symbol f. (If the same symbol occurs with different arities, it is interpreted by a different function for each arity.) The function λ^{∗}, which takes a variable x and an M-term t as arguments, does not need to be defined on terms t containing Skolem terms with x free.

We show that a single quantifier can be eliminated. Consider a theorem T containing an axiom ∀x∃y A(x, y), and consider the theory T^{∗} containing a new a Skolem function symbol f and the axiom ∀x A(x, f(x)) instead of the axiom ∀x∃y A(x, y). Note that this axiom is a formula of Skolem lambda logic since A(x, f(x)) means A[y := f(x)] and any bound variables that occur free in f(x) are renamed as part of the substitution process, so no free variables of the Skolem term f(x) are captured by a lambda-binding.

We claim T has a model if and only if T^{∗} has a model. A model of T^{∗} already satisfies T, so only one direction requires proof. Suppose M satisfies T. Then for every x ∈ M there is a y ∈ M such that M satisfies A(x, y). Using the axiom of choice (at the meta-level) there is a function f̄ : M → M such that M satisfies A(x, f̄(x)) for every x. We take f̄ as the interpretation of f. Then the axiom ∀x A(x, f(x)) is satisfied. We have to extend the function λ^{∗} of M (which takes a variable and an M-term and produces an M-term) to be defined on M-terms in the language of T^{∗}. We also have to define the interpretations r̄ of terms in Skolem lambda logic in M. These two tasks are accomplished simultaneously by mutual recursion; the function λ^{∗} is used just as for lambda calculus to define the interpretation of lambda-terms, and now we show how to extend λ^{∗} to those lambda terms that are legal in Skolem lambda logic. Let t be an M-term of T^{∗}, and x a variable, and suppose that t contains some Skolem M-subterms, but does not contain any Skolem subterms with x free. Then t can be written as t′[u := r], where u stands for several variables and r for the list of all Skolem subterms of t, and t′ does not contain any Skolem terms. Since the terms r do not contain x free, the variable x does not get renamed when we substitute r for u in lambda(x, t′). Thus

λ(x, t′)[u := r] = λ(x, t′[u := r]) = λ(x, t)

We define

λ^{∗}(x, t) := lambda^{∗}(x, t′[u := cr̄

where r̄ is the interpretation in M of the Skolem term r and cr̄ is the constant denoting that element of M.

Now we check the validity of axiom (β). Let r be a list of all Skolem terms occurring in t and u a corresponding list of variables not occurring in t. Let t′ be a term such that t = t′[u := r], and t′ contains no Skolem terms. In M we have

Ap(lambda(x, t), q) = Ap(λ^{∗}(x, t), q)
= Ap(λ^{∗}(x, t′[u := cr̄], barq)  by definition of λ^{∗}(x, t)
= Ap(λ(x, t′)[u := cr̄]), q̄)  since x does not occur free in r̄
= Ap(λ(x, t′), q̄)[u := cr̄]  since cr̄ is a constant term
= t′[x : q̄][u := cr̄  since axiom (β) holds in M
= t[x := q̄]

Finally we check the validity of the weak extensionality axiom (ξ). Recall that the axiom in question says that if for all x, Ap(t, x) = Ap(s, x), then λ(x, Ap(t, x)) = λ(x, Ap(s, x)). This is an axiom of Skolem lambda logic only in case t does not contain any Skolem subterms with x free. In that case, let t′ and s′ be terms without Skolem subterms, and r a list of Skolem terms, such that λ^{∗}(x, t) = λ^{∗}(x, t′[u := cr̄]) and λ^{∗}(x, s) = λ^{∗}(x, s′[u := cr̄]) Then in M, by hypothesis we have Ap(t, x) = Ap(s, x) for all x, so also Ap(t′[u := r], x) = Ap(s′[u := r], x). Since the interpretation in M of t′[u := r] is the same as that of the M-term t′[u := cr̄], we also have

Ap(t′[u := cr̄], x) = Ap(s′[u := cr̄], x).

But these terms contain no Skolem subterms. Hence, applying axiom (ξ) in M, we have

lambda(x, t′[u := cr̄]) = lambda(x, s′[u := cr̄]).

Therefore M satisfies

λ(x, t′[u := r]) = λ(x, s′[u := r]),

which is the same as to say M satisfies λ(x, t) = λ(x, s). That completes the verification of axiom (ξ).

Now, as usual in first-order logic, we can eliminate quantifiers one by one in favor of Skolem functions, so that to every theory T in lambda logic, we can construct a theory T^{∗} in Skolem lambda logic with quantifier-free axioms, such that T has a model if and only if T^{∗} has a model. Hence it suffices to prove the completeness theorem for quantifier-free Skolem lambda logic.

If T does not contain infinitely many constant symbols, we begin by adding them; this does not destroy the consistency of T since in any proof of contradiction, we could replace the new constants by variables not occurring elswhere in the proof. We construct the “canonical structure” M for a theory T. The elements of M are equivalence classes of closed terms of T under the equivalence relation of provable equality: t ∼ r iff T ⊢ t = r. Let [t] be the equivalence class of t. We define the interpretations of constants, function symbols, and predicate symbols in M as follows:

c^{M} = [c]
f^{M}([t_{1}], …, [t_{n}]) = [f(t_{1}, …, t_{n})]
P^{M}([t_{1}], …, [t_{n})] = [P (t_{1}, …, t_{n})]

In this definition, the right sides depend only on the equivalence classes [t_{i}] (as shown in [10], p. 44).

Exactly as in [10] one then verifies that M is a first order model of T. To turn M into a λ-model, we must define λ^{∗}(x, [t]), where x is a variable and t is an M-term, i.e. a closed term with parameters from M, and t does not contain Skolem subterms in which x occurs free. The “parameters from M” are constants c_{[q]} for closed terms q of T. If t is an M-term t, let [t]^{∘} be the closed term of T obtained from t by replacing each constant c_{[q]} by a closed term q in the equivalence class [q]. Then [t]^{∘} is well-defined. Define λ^{∗}(x, [t]) = [λx. [t]^{∘}]. By axiom (ξ), this is a well-defined operation on equivalence classes: if T proves t = s then T proves [t]^{∘} = [s]^{∘} and hence λx. [t]^{∘} = λx. [s]^{∘}.

We verify that the axioms of lambda logic hold in M. First, the (β) axiom: Ap(λx. t, r) = t[x := r]. It suffices to consider the case when t has only x free. The interpretation of the left side in M is the equivalence class of Ap(λx. t, r). The interpretation of the right side is the class of t[x := r]. Since these two terms are provably equal, their equivalence classes are the same, verifying axiom (β). Now for axiom (ξ). Suppose t and s are closed terms and Ap(t, x) = Ap(s, x) is valid in M. Then for each closed term r, we have tr provably equal to sr. Since T contains infinitely many constant symbols, we can select a constant c that does not occur in t or s, so tc = sc is provable. Replacing the constant c by a variable in the proof, tx = sx is provable. Hence by axiom (ξ), λx. t = λx. s is probable, and hence that equation holds in M. In verifying axiom (ξ), it suffices to consider the case when s and t are closed terms. The axiom (α) holds in M since it simply asserts the equality of pairs of provably equal terms. The axiom T ≠ F holds since T does not prove T = F, because T is consistent. That completes the proof.

8 The first order fragment of lambda logic

Theorem 4 (Axiomatization of first-order theorems) Let T be a first order theory, and let A be a first order sentence. Then T proves A in lambda logic if and only if for some positive integer n, T plus “there exist n distinct things” proves A in first order logic.

Proof. First suppose A is provable from T plus “there exist n distinct things”. We show A is provable in lambda logic, by induction on the length of the proof of A. Since lambda logic includes first order logic, the induction step is rivial. For the basis case we must show that lambda logic proves “there exist n distinct things” for each positive integer n. The classical constructions of numerals in lambda calculus produce infinitely many distinct things. However, it must be checked that their distinctness is provable in lambda logic. Defining numerals as on p. 130 of [1] we verify by induction on n that for all m < n, ⌈m⌉ ≠ ⌈n⌉ is provable in lambda logic. If m < n + 1 then either m = n, in which case we are done by the induction hypothesis, or m = n. So what has to be proved is that for each n, lambda logic proves ⌈n⌉ ≠ ⌈n + 1⌉. This in turn is verifiable by induction on n.

Conversely, suppose that A is not provable in T plus “there exist n distinct things” for any n. Then by the completeness theorem for first order logic, there is an infinite model M of ¬A; indeed we may assume that M has infinitely many elements not denoted by closed terms of T. We will show that M can be expanded to a lambda model M̂ satisfying the same first order formulas, by defining arbitrarily the required operation λ^{∗} on M-terms, and then inductively defining relations E(x, y) and Ap_{M} to serve as the interpretations of equality and Ap in M̂.

To do this we define the relation Ap_{M} and a binary relation E on M by simultaneous induction. Ap_{M} will serve as the interpretation of Ap and E will serve as the interpretation of equality.^{2} Since M is infinite we can define an element 0 and a pairing function ⟨a, b⟩ on M in such a way that the interpretations of the losed terms of T are never pairs, and 0 is not a pair. Define < a, b, c >=< a, < b, c >>, etc. Define the successor of x to be s(x) =< 0, x >, and define the “numeral” m̄ inductively by ¯0 = 0 and m̄ + 1 = s(m̄). Henceforth we drop the bars, writing for example ⟨1, k⟩ instead of ⟨¯1, k̄⟩. An element of the form < 1, j, k > will be used as an “index” of the k-th function symbol of arity j in T, which we denote by f_{k}^{j}.

Tuples are defined from pairs by ⟨x_{1}, …, x_{n+1}⟩ = ⟨⟨x_{1}, …, x_{n}⟩, x_{n+1}⟩. The members of a tuple ⟨x_{1}, …, x_{n} are the x_{i} for i = 1, …, n. When y and w are two tuples of length at least m we write E_{m}(y, w) for the conjunction of the formulas E(y_{i}, w_{i}) for i ≤ m.

To produce a λ-model we must define an operation λ^{∗}, which takes a variable and an M-term. An M-term (as explained in [1], p. 86 ff.), is a term with “parameters from M”; more precisely, a closed term in a language containing a constant c_{a} for each element a of M. A convenient notation for M-terms is t[y], where y is a tuple of elements of M whose length is the number of free variables of t. This means the following: if x_{1}, …, x_{n} are the free variables of t, in order of their occurrence, then t[y] is t[x_{i} := c_{y_{i}}]. We also need the following notation: t[y, x] where x is a variable, and y is a tuple of elements of M whose length is the number of free variables of t different from x, means the following: if x_{1}, …, x_{n} are the free variables of t different from x, in order of their occurrence, then t[y] is t[x_{i} := c_{y_{i}}]. Note that x may or may not occur free in t.

The operation λ^{∗} is given by

λ^{∗}(x, t[y, x]) :=< 2, j,^{⌈}t^{⌉}, y >

where y is a tuple whose length is the number of free variables of λx. t, and x is the j-th variable, and ^{⌈}t^{⌉} is the (numeral for the) Gödel number of the closed term t. The definitions of Ap, E, and the interpretation t[y]_{M} of each M-term t[y] are given in one simultaneous inductive definition. The inductive conditions are as follows. In (iii) and (iv), m is the number of free variables of t.

(i) E(x, y) if x = y.

(ii) E(λ^{∗}(x, t[y, x]), λ^{∗}(z, t[x := z][y])).

(iii) Ap_{M}(λ^{∗}(x, t[y, x]), r_{M}) = t[x := r][y]_{M}.

(iv) E(λ^{∗}(x, t[y, x]), λ^{∗}(x, s[w, x]) if E(t[x := a][y]_{M}, s[x := a][w_{M}), and E_{m}(y, w) where a is a the first constant not occurring in t or s.

(v) E(Ap_{M}(a, b), Ap_{M}(c, d)) if E(a, c) and E(b, d).

(vi) Ap(a, b)_{M} = Ap_{M}(a_{M}, b_{M}).

(vii) E(f(t[y])_{M}, f(s[w])_{M}) if E(t[y]_{M}, s[w]_{M}), and similarly for several variables x.

(viii) (λx. t[y, x])_{M} = λ^{∗}(x, t[y, x]).

(ix) f(x)_{M} = f_{M}(x_{M}) and similarly for several variables x.

2If one insists on interpreting equality as identity instead of by an equivalence relation, one may use the equivalence classes of E as the elements of the model.

(x) (c_{a})_{M} = a where c_{a} is the constant for a.

(xi) E(a, c) if E(a, b) and E(b, c).

Since E and Ap occur only positively in these clauses, this is a legitimate inductive definition. We interpret equality in M as the relation E. For each predicate P of arity n in the language of T, we define a relation P̂ on M by

P̂(x_{1}, …, x_{n}) := M ⊧ P (y_{1}, …, y_{n}) ∧ E_{n}(x, y)

and we define M̂ ⊧ P (x_{1}, …, x_{n}) if and only if P̂(x_{1}, …, x_{n}).

We start with the following lemma: if E(r, q) then E(t[x := r], t[x := q]) for terms t, q, and r. This is proved by induction on the complexity of the M-term t. When t begins with λ or Ap, the corresponding induction step follows from (iv) and (v). When t begins with a function symbol f, we use (vii). When t is atomic, either it is a constant c_{a} for an element a = y_{1} of M, in which case there is nothing to prove, or else it is a variable, in which case we have to prove that E(r, q) from the assumption E(r, q), which is immediate.

We next verify the substitutivity of equality, namely: if E(r, s) and M̂ ⊧ A[x := r] then M̂ ⊧ A[x := s], where A is a formula of lambda logic with constants for elements of M. We prove this by induction on the complexity of A. Since substitution for free variables commutes with the logical connectives and quantifiers, only the case of atomic A needs a proof. If A is an equality t = q, then A[x := r] is t[x := r] = q[x := r] and A[x := s] is t[x := s] = q[x := s]. By the lemma we have t[x := r] = t[x := s] in M, and q[x := r] = q[x := s]. Assume M̂ ⊧ A[x := r]. Then by (xi) we have M̂ ⊧ t[x := s] = q[x := s]. The remaining case is when A is an atomic formula P (x) (x can be several variables.) This is taken care of by the definition of P̂ above.

Because of (ii) and (iii), axioms (α) and (β) are satisfied. Now to verify axioms (ξ). Let t[y] be an M-term, i.e. a term with constants for elements y of M substituted for its free variables. Suppose M̂ ⊧ ∀x(t[y]x = s[y]x). Then let c be the first constant not occurring in t or s; we have M̂ ⊧ t[x := c] = s[x := c]. Then by (iv), we have M̂ ⊧ λx. t[y] = λx. s[y]. Hence (ξ) holds in M.

We have now proved that M̂ is a model of lambda logic. We still must prove it satisfies the theory T in first order logic. This follows from the following lemma: For each M-formula A(x_{1}, …, x_{n}) with n parameters from M, we have M̂ ⊧ A(x) if and only if there exists y with E_{n}(x, y) and M ⊧ A(y). To prove the lemma: The case when A is an atomic formula P (x) is true by definition of P̂. The case of an atomic formula t = q follows from what has been proved above. The proof is completed by induction on the complexity of A; the quantifiers do not offer any difficulty since the carrier sets of M and M̂ are the same. That completes the proof of the theorem.

9 Lambda Unification

Above we defined t[x := s] as the result of substituting term s for free variable x in t, after renaming bound variables in t to avoid capture of free variables of s. At that time we did not extend this definition to simultaneous (or “parallel”) substitution for several variables x_{1}, …, x_{n}, but this can be done as usual. The free variables of t are renamed to avoid clashes with free variables in s_{1}, …, s_{n}, and then each variable x_{i} is replaced by s_{i} at the same time (rather than sequentially).

A substitution is a function σ from a set of variables to the set of terms. It is traditional to write xσ instead of σ(x). A substitution σ has a natural extension to a function from terms to terms, which we also denote by σ, given by tσ = t[x := xσ], where x stands for the list of all free variables in t, and t[x := xσ] denotes a simultaneous substitution.

In first order logic, a substitution σ is said to be a unifier of terms t and s if tσ = sσ. Two terms in first order logic (with equality) are provably equal if and only if they are identical, so it doesn’t matter if we interpret this to mean that tσ = sσ is provable in first order logic with equality or just that the terms tσ and sσ are identical. When we go to generalize this to lambda logic, it does matter, since terms can be syntactically different but provably equal (for example if one β-reduces to the other).

We define σ to be a lambda unifier of terms t and s if tσ = sσ is provable in lambda logic. Similarly, σ is defined to be a lambda unifier of formulas A and B if A ↔ B is provable in lambda logic.

Our aim here is to give another axiomatization of lambda logic, based on resolution, factoring, and paramodulation. The usual formulation of these rules involves unifiers. We extend these rules to lambda unification as follows:

Paramodulation

α = β P [x := γ] ασ = γσ

paramodulation

P [x := βσ].

provided that the free variables of βσ either occur in γ or are not bound in P. This differs from the first order version of paramodulation only in the extra condition about the free variables of βσ. Note that inferences by β-reduction are included in the paramodulation rule, taking α = β to be the axiom of β-reduction and γ to be α.

Binary Resolution

Aσ ↔ Bσ  A | U  − B | V

binary resolution

Uσ | V σ

Here U and V are sets of literals and U | V is their union; −B is a negative literal, i.e. a negated atom; A | U means the union of {A} with U; and Uσ means {P σ : P ∈ U}.

Factoring

Aσ ↔ Bσ A |B | U

\overline{factoring}

Aσ | Uσ

We identify a clause with the formula of λ-logic which is the disjunction of the literals of the clause. If Γ is a set of clauses, then Γ can also be considered as a set of formulas in λ-logic.

Theorem 5 (Soundness of lambda unification) (i) Suppose there is a proof of clause C from a set of clauses Γ using binary resolution, factoring, and paramodulation, and the clause x = x. Then there is a proof of C from Γ in lambda logic.

Remark. In [6], “demodulation” is mentioned, but it is not necessary to consider demodulation as a separate rule of inference—from the purely logical viewpoint, demodulation is a special case of paramodulation. Proof. We proceed by induction on the lengths of proofs, In the base case, if we have a proof of length 0, the clause C must already be present Γ, in which case certainly Γ ⊢ C in lambda logic.

For the induction step, we first suppose the last inference is by paramodulation. Then one of the parents of the inference is an equation α = β (or β = α) where the other parent ϕ has the form ψ[x := γ] where for some substitution σ we have γσ = ασ, and the free variables of βσ either occur in γ or are not bound in ψ, according to the definition of paramodulation. Then the newly deduced formula is ψ[x := βσ]. We have to show that this formula is derivable in lambda logic from the parents ϕ and α = β. Apply the substitution σ to the derived formula ϕ. We get

ϕσ = ψ[x := γ]σ
= (ψσ)[x := γσ]
= (ψσ)[x := ασ]

Now using the other deduced equation α = β, we can deduce ασ = βσ and hence we can, according to the rules of lambda logic, substitute βσ for ασ, provided the free variables in βσ either occur already in ασ or are not bound in ψσ. Since γ = ασ, this is exactly the condition on the variables that makes the application of paramodulation legal. That completes the induction step in the case of a paramodulation inference.

If the last inference is by factoring, it has the form of applying a substitution σ to a previous clause. This can be done in lambda logic. (In the factoring rule, as in lambda logic, substitution must be defined so as to not permit capture of free variables by a binding context.)

If the last inference is by binary resolution, then the parent clauses have the form P |R and −Q|S (using R and S to stand for the remaining literals in the clauses), and substitution σ unifies P and Q. The newly deduced clause is then Rσ|Sσ. Since the unification steps are sound, P σ = Qσ is provable in λ-logic. By induction hypothesis, λ-logic proves both P |R and −Q|S from assumptions Γ, and since the substitution rule is valid in λ-logic, it proves P σ|Rσ and −Qσ|Sσ. But since P σ = Qσ is provable, λ-logic proves Rσ|Sσ from Γ. This completes the induction step, and hence the proof.

10 The Logic of Partial Terms

In the group theory example, it is natural to ask whether x · y needs to be defined if x or y does not satisfy G(x). In first order logic, · is a function symbol and hence in any model of our theory in the usual sense of first order logic, · will be interpreted as a function defined for all values of x and y in the model. The usual way of handling this is to say that the values of x · y for x and y not satisfying G(x) or G(y) are defined but irrelevant. For example, in first order field theory, 1/0 is defined, but no axiom says anything about its value. As this example shows, the problem of “undefined terms” is already of interest in first order logic, and two different (but related) logics of undefined terms have been developed. We explain here one way to do this, known as the Logic of Partial Terms (LPT). See [5] or [4], pp. 97-99.

LPT has a term-formation operator ↓, and the rule that if t is a term, then t ↓ is an atomic formula. One might, for example, formulate field theory with the axiom y ≠ 0 → x/y ↓ (using infix notation for the quotient term). Thereby one would avoid the (sometimes) inconvenient fiction that 1/0 is some real number, but it doesn’t matter which one because we can’t prove anything about it anyway; many computerized mathematical systems make use of this fiction. Taking this approach, one must then modify the quantifier axioms. The two modified axioms are as follows:

∀x A ∧ t ↓→ A[x := t]
A[x := t] ∧ t ↓→ ∃x A

Thus from “all men are mortal”, we are not able to infer “the king of France is mortal” until we show that there is a king of France. The other two quantifier axioms, and the propositional axioms, of first order logic are not modified. We also add the axioms x ↓ for every variable x, and c ↓ for each constant c.

In LPT, we do not assert anything involving undefined terms, not even that the king of France is equal to the king of France. The word “strict” is applied here to indicate that subterms of defined terms are always defined. LPT has the following “strictness axioms”, for every atomic formula R and function symbol f. In these axioms, the x_{i} are variables and the t_{i} are terms.

R(t_{1}, …, t_{n}) → t_{1} ↓ ∧ … ∧ t_{n} ↓
f(t_{1}, …, t_{n}) ↓→ t_{1} ↓ ∧ … ∧ t_{n} ↓
t_{1} ↓ ∧ … ∧ t_{n} ↓ ∧f(x_{1}, …, x_{n}) ↓→ f(t_{1}, …, t_{n}) ↓

Remark. In LPT, while terms can be undefined, formulas have truth values just as in ordinary logic, so one never writes R(t) ↓ for a relation symbol R. That is not legal syntax.

For example, one of the strictness axioms is

t = r → t ↓ ∧r ↓ .

We write t ≅ r to abbreviate t ↓ ∨r ↓→ t = r. It follows from the strictness axiom just stated that t ≅ r really means “t and r are both defined and equal, or both undefined.”

The equality axioms of LPT are as follows (in addition to the one just mentioned):

x = x
x = y → y = x
t ≅ r ∧ ϕ[x := t] → ϕ[x := r]

11 Partial Lambda Calculus

In lambda calculus, the issue of undefined terms arises perhaps even more naturally than in first order logic, as it is natural to consider partial recursive functions, which are sometimes undefined.^{3}

Partial lambda calculus is a system similar to lambda calculus, but in which Ap is not necessarily total. There can then be “undefined terms.” Since lambda calculus is a system for deducing (only) equations, the system has to be modified. We now permit two forms of statements to be deduced: t ≅ r and t ↓. The axioms (α), (β), and (ξ) are modified by changing = to ≅, and the rules for deducing t ↓ are specified as follows: First, we can always infer (without premise) x ↓ when x is a variable. Second, we can apply the inference rules

\frac{t ≅ s  t ↓}{s ↓}  \frac{t ≅ s  s ↓}{t ↓}
\frac{t ↓  r ↓}{t[x := r] ↓}  λx. t ↓

Note that we do not have strictness of Ap. As an example, we have Ap(λy. a, b) ≅ a, whether or not b ↓. We could have formulated a rule “strict (β)” that would require deducing r ↓ before concluding Ap(λx. t, r) ≅ t[x := r], but not requiring strictness corresponds better to the way functional programming languages evaluate conditional statements. Note also that λx. t is defined, whether or not t is defined.

12 Partial Lambda Logic

Partial lambda logic results if we make similar modifications to lambda logic instead of to first order logic or lambda calculus. In particular we modify the rules of logic and the equality axioms as in LPT, add the strictness axiom (except for Ap), and modify the axioms (α), (β), and (ξ) by replacing = with ≅. In LPT, ≅ is an abbreviation, not an official symbol; in partial lambda calculus it is an official symbol; in partial lambda logic we could make either choice, but for definiteness we choose to make it an official symbol, so that partial lambda logic literally extends both LPT and partial lambda calculus. The first three rules of inference listed above for partial lambda calculus are superfluous in the presence of LPT. The fourth one (actually an axiom, not a rule) is included in partial lambda logic.

3There is, of course, an alternative to λ-calculus known as combinatory logic. Application in combinatory logic is also total, but in [4], the notion of a partial combinatory algebra is introduced and studied, following Feferman, who in [7] first introduced partial applicative theories. See [8] for some relationships between partial combinatory logic and partial lambda calculus

Here for reference are the axioms of partial lambda logic:

(λ terms always defined) λx. t ↓ for each term t.

(Prop) propositional axioms (see [10], p. 20)

(Q) quantifier axioms for LPT as given above

(Strictness)

R(t_{1}, …, t_{n}) → t_{1} ↓ ∧ … ∧ t_{n} ↓
f(t_{1}, …, t_{n}) ↓→ t_{1} ↓ ∧ … ∧ t_{n} ↓ if f is not Ap
t_{1} ↓ ∧ … ∧ t_{n} ↓ ∧f(x_{1}, …, x_{n}) ↓→ f(t_{1}, …, t_{n}) ↓

(α) t ≅ s if t and s are alpha-equivalent.

(β) Ap(λx. t, s) ≅ t[x := s]

(β) Ap(λx. B, s) ↔ B[x := s] when B is a formula.

(ξ) (weak extensionality) ∀x(Ap(t, x) ≅ Ap(s, x)) → λx. Ap(t, x) ≅ λx. Ap(s, x)

(true and false) T = λxλy. x and F = λxλy. y

(non-triviality) T ≠ F

We review the semantics of LPT as given in [5], [4]. A model consists of a set and relations on that set to interpret the predicate symbols; the function symbols are interpreted by partial functions instead of total functions. Given such a partial structure one defines simultaneously, by induction on the complexity of terms t, the two notions M ⊧ t ↓ and t_{M}, the element of M that is denoted by t.

We now discuss the semantics of partial lambda logic. The definition of partial λ-model is similar to that of λ-model, except that now Ap and the other function symbols can be interpreted by partial functions instead of total functions. The function λ^{∗} in the definition of λ-model (which takes a variable and an M-term as arguments) is required to be total, so that the axiom λx. t ↓ will be satisfied.

Definition 2 (Partial lambda model) (M, λ^{∗}) is a partial λ-model of a theory T in partial lambda logic if (M, λ^{∗}) satisfies the axioms (α), (ξ), and (β), and M satisfies all the axioms of T and LP T, except that Ap need not be strict.

The following theorem generalizes the completeness theorem for LPT to partial lambda logic.^{4}

Theorem 6 (Lambda Completeness Theorem for LPT) Let T be a consistent theory in partial lambda logic. Then T has a partial lambda model.

Proof. As for (total) lambda logic, we have to extend partial lambda logic to allow Skolem functions, not allowing the construction of lambda terms that capture free variables in Skolem terms. Exactly as for lambda logic, every theory T in partial lambda logic has a Skolemized version T^{∗} in Skolem partial lambda logic, such that T has a model if and only if T^{∗} has a model. It therefore suffices to prove the completeness of quantifier-free Skolem partial lambda logic.

To do that, we again imitate the Henkin proof of completeness for first order logic. If T does not contain infinitely many constant symbols, we begin by adding them; this does not destroy the consistency of T since in any proof of contradiction, we could replace the new constants by variables not occurring elswhere in the proof. We construct the “canonical structure” M for a theory T. The elements of M are equivalence classes of closed terms of T under the equivalence relation of provable equality: t ∼ r iff T ⊢ t = r. But now, we take only those closed terms t for which T proves t ↓; that ensures the validity of the axiom x = x, and of the axioms x ↓ for variables x and of the axioms c ↓ for constants c. Let [t] be the equivalence class of t. We define the interpretations of constants, function symbols, and predicate symbols in M as follows:

c^{M} = [c]
f^{M}([t_{1}], …, [t_{n}]) = [f(t_{1}, …, t_{n})]
P^{M}([t_{1}], …, [t_{n})] = [P (t_{1}, …, t_{n})]

In this definition, the right sides depend only on the equivalence classes [t_{i}] (as shown in [10], p. 44). The atomic formula t ↓ is satisfied in M if and only if T proves t ↓. It follows by induction on the complexity of the closed first-order term t that if T proves t ↓ then the interpretation t^{M} of t in M is the equivalence class [t] of t. The strictness axiom for first order function symbols is used in the induction step, so this does not apply to terms containing Ap unless we have strictness for Ap.

Exactly as in [10] one then verifies that M is a first order model of T in the sense of LPT. Thus the completeness theorem for first order LPT (with strictness) is proved (again–it was first proved in [5]).

To turn M into a λ-model, we must define λ^{∗}(x, t), where t is an M-term, i.e. a closed term with parameters from M. The “parameters from M” are constants c_{[}q], where [q] is the equivalence class of a closed term q of T. If [t] is the equivalence class of an M-term t, let [t]^{∘} be a closed term of T obtained from t by replacing each constant c_{[}q] by some closed term q in the equivalence class [q]. Which closed term we select does not affect the equivalence class [t]^{∘}. In other words, [t]^{∘} is a well-defined operation on equivalence classes.

4In [5] there is a completeness theorem for LPT, generalizing Gödel’s completeness theorem.

The strictness axiom is important in the proof.

We define λ^{∗}(x, t) = [λx. [t]^{∘}]. Because of the axiom λx. t ↓, λ^{∗}(x, t) is indeed defined for M-terms t. We must show that the value depends only on the equivalence class [t]. Suppose T proves t = s. Then by axiom (xi), T proves λx. [t] = λx. [s].

We verify that the axioms of partial lambda logic hold in M. First, the beta axiom: Ap(λx. t, r) ≅ t[x := r]. It suffices to consider the case when t has only x free. Suppose that the left hand side is defined in M. Its interpretation is the equivalence class of Ap(λx. t, r). By axiom (β), the right side is provably equal to the left side, so it is defined in M, and its interpretation is the class of t[x := r]. On the other hand if the right hand side is defined in M, then it is provably equal to the left side and so both are defined and equal in M. This verifies axiom (β).

Now for axiom (ξ). Suppose t and s are closed terms defined in M, and Ap(t, x) ≅ Ap(s, x) is valid in M. Then for each closed term r such that T proves r ↓, we have tr provably equal to sr. Since T contains infinitely many constant symbols, we can select a constant c that does not occur in t or s, so tc = sc is provable. Replacing the constant c by a variable in the proof, tx = sx is provable. Hence by axiom (ξ), λx. t = λx. s is probable, and hence that equation holds in M. In verifying axiom (ξ), it suffices to consider the case when s and t are closed terms. The axiom (α) holds in M since it simply asserts the equality of pairs of provably equal terms. The axiom T ≠ F holds since T does not prove T = F, because T is consistent. That completes the proof.

13 Partial lambda logic in terms of resolution and paramodulation

In the resolution and paramodulation axiomatization of lambda logic (and first order logic for that matter) we use the axiom x = x, since paramodulation does not include reflexivity. In partial lambda logic, we replace the axiom x = x by the clause −E(x)|x = x, where E(t) is a syntactic variant of t ↓. We also add the clause x ≠ x|E(x), thus expressing that t ↓ is equivalent to t = t. The soundness theorem takes the following form:

Theorem 7 (Soundness of lambda unification for LPT)

Suppose there is a proof of clause C from a set of clauses Γ using binary resolution, factoring, demodulation (including β-reduction), and paramodulation, the clauses x = x| − E(x) and −E(x)|x = x, and clauses expressing the strictness axioms, allowing second order unification in place of first order unification. Then there is a proof of C from Γ in partial lambda logic.

Proof. The proof is similar to the proof for lambda logic, except for the treatment of β-reduction steps. When β-reduction is applied, we only know that ≅ holds in partial lambda logic. But since in partial lambda logic, we have the substitutivity axioms for ≅ as well as for =, it is still the case in partial lambda logic that if P [x := Ap(λz. t, r)] is used to deduce P [x := t[z := r]], and if (by induction hypothesis) the former is derivable in partial lambda logic plus AC, then so is the latter. For example if Ap(λz. a, Ω) = a is derivable, then a = a is derivable. Each of these formulas is in fact equivalent to a ↓.

References

[1] Barendregt, H., The Lambda Calculus: Its Syntax and Semantics, Studies in Logic and the Foundations of Mathematics 103, Elsevier Science Ltd. Revised edition (October 1984).

[2] Barendregt, H., Bunder, M., and Dekkers, W., Systems of illative combinatory logic complete for first order propositional and predicate calculus Journal of Symbolic Logic 58 (3), 89-108, 1993.

[3] Barendregt, H., Bunder, M., and Dekkers, W., Completeness of two systems of illative combinatory logic for first order propositional and predicate calculus Archive für Mathematische Logik 37, 327–341, 1998.

[4] Beeson, M., Foundations of Constructive Mathematics, Springer-Verlag, Berlin Heidelberg New York (1985).

[5] Beeson, M., Proving programs and programming proofs, in: Barcan, Marcus, Dorn, and Weingartner (eds.), Logic, Methodology, and Philosophy of Science VII, proceedings of the International Congress, Salzburg, 1983, pp. 51-81, North-Holland, Amsterdam (1986).

[6] Beeson, M., Lambda logic, in Basin, David; Rusinowitch, Michael (eds.) Automated Reasoning: Second International Joint Conference, IJCAR 2004, Cork, Ireland, July 4-8, 2004, Proceedings. Lecture Notes in Artificial Intelligence 3097, pp. 460-474, Springer (2004).

[7] S. Feferman, Constructive theories of functions and classes, pp. 159-224 in: M. Boffa, D. van Dalen, and K. McAloon (eds.), Logic Colloquium ’78: Proceedings of the Logic Colloquium at Mons, North-Holland, Amsterdam (1979).

[8] E. Moggi. The Partial Lambda-Calculus. PhD thesis, University of Edinburgh, 1988. http://citeseer.nj.nec.com/moggi88partial.html

[9] Scott, D., Identity and existence in intuitionistic logic, in: Fourman, M. P., Mulvey, C. J., and Scott, D. S. (eds.), Applications of Sheaves, Lecture Notes in Mathematics 753 660-696, Springer–Verlag, Berlin Heidelberg New York (1979).

[10] Shoenfield, J. R., Mathematical Logic, Addison-Wesley, Reading, Mass. (1967).