Download Recursion on Abstract Structures and more Lecture notes Theory of Computation in PDF only on Docsity!
Recursion on Abstract Structures
by Peter G. Hinman
ABSTRACT. We develop and compare two models for computability over an abstract structure. The first, characterized in term of generalized register machines, provides a good theory for a large class of first-order structures. The second, defined in terms of minimal solutions for functional equations, is more versatile and handles many common second-order examples.
- Introduction
- Structures and Functionals
- Register Machines
- Recursion
- Examples
- Structures with Arithmetic
- Sections and Envelopes
- Appendix
1. Introduction
From its origins as a theory of computable functions of natural numbers, Recursion Theory has been extended and generalized to include many other sorts of ‘computable’ functions. The first such extensions were directed towards establishing theories of computability over particular domains, such as initial segments of the ordinal numbers or the finite-type structure over the natural numbers. Later work developed theories of computabilty over abstract structures, initially first-order structures, then special sorts of second-order struc- tures. Along the way appeared several still more abstract axiomatic computation theories. Our goal here is to survey some of these developments with an emphasis on the role of inductive definability as the basic principle of general computability. We make no claim to completeness.
One of the striking features of ordinary (or ‘classical’) Recursion Theory is the diversity of equivalent formal characterizations. Most of these fall into one of three general classes by characterizing a (partial) recursive function(al) as one which
(1) is computable by an abstract machine, such as a Turing or register machine;
(2) is definable in existential form in an interpreted formal language such as first-order arithmetic or an equational calculus;
(3a) belongs to the smallest class of functions which contains certain very simple functions and is closed under a small number of generating principles;
(3b) is represented by objects belonging to some other inductively defined set.
Attempts to develop generalized notions of computability have made use of extended versions of each of these. A full review of these efforts would merit a (long!) article to itself, and we mention here only some of the highlights.
Characterizations of computability based on abstract machines have a natural appeal, although they have not been uniformly successful. For example, a version of Turing ma- chines for recursion in finite types was worked out carefully in [Kl3,4], but this approach was largely neglected by subsequent research in favor of the inductive definability (3b) approach of [Kl1,2]. On the other hand, Friedman’s notion [Fr] of a finite algorithmic pro- cedure (FAP) over any first-order structure was elaborated in the articles [MS-HT1and 2] and [Tu] (or see the excellent summary in [Fe; Chapter 0]) and more recently the article [BSS] characterizes a natural notion of computability over the real numbers — and more generally over any ring — in terms of a kind of register machine. We shall develop this approach in several sections below.
In the book [TuZu1] and the series of papers [TuZu2-5] Tucker and Zucker explore several other notions of computability over abstract algebras. Among other topics these works consider versions of μ-recursion, while-programs, semi-computability, flow charts, infinitary quantifier-free definability, and computable functionals. Some of these build on earlier work of Engeler [En1,2] and Herman and Isard [HeIs]. Most of these notions coincide extensionally with one of those described below.
Definability has been a very successful framework for certain parts of Generalized Recursion Theory. It was early recognized that for an admissible ordinal α, existential definability over the segment Lα of the hierarchy of constructible sets is a natural and useful characterization of the partial α-recursive functions. The point is that just as the computation process for obtaining the value of an ordinary recursive function can be coded as a natural number, so the corresponding process over an admissible ordinal α can be coded as a member of Lα. This idea was extended in the Companion Theorem [Mo1; 9E1] which shows that for any Spector class Γ of relations (an analogue of the semi-recursive relations) over a transitive infinite set A (in particular an infinite ordinal), there exists an admissible set M ⊇ A such that (among other properties) the members of Γ are exactly the relations Σ 1 definable over M relative to a single fixed relation. This more complex method is necessary because most structures are not rich enough to code the relevant computations. This approach will not play a big role in this article.
It has turned out that approach (3) has the widest range of application. Not only does it work in more contexts, but it seems more intrinsic in avoiding reference to other constructs such as machines or formulas. The ordinary partial recursive functions over ω form the smallest class which contains some simple functions (for example, the primitive recursive functions) and is closed under composition and search. In developing the theory of recursion for finite types, Kleene (in [Kl1,2]) relied on method (3b) in defining inductively a class C of tuples of the form (a, x, n), where a, n ∈ ω and x is a finite sequence of finite- type objects, and calling a function F partial recursive iff for some (index) a, F = {a}, where for all x and n,
{a}(x) n ⇐⇒ (a, x, n) ∈ C.
Let PflA denote the set of all l-ary partial functions on A — that is, partial maps f : Al^ → A. Then a finitary functional on A is a partial mapping
F : Ak^ × Pfl A^0 × · · · × Pf ln− 1 A →^ A,
for some type (k; l) = (k; l 0 ,... , ln− 1 ). In particular, a k-ary partial function is also a functional of type (k; ). To specify the value of such a functional we often write F (a, f ) e. Thus a represents a 0 ,... , ak− 1 and f represents f 0 ,... , fn− 1 (for unspecified k and n, which are either determined by context or are arbitrary). The relation is read ‘is defined and equal to’.
We shall be concerned exclusively with monotone functionals, which have the property
F (a, f ) e and
i<n
[fi ⊆ gi] =⇒ F (a, g) e.
Here, of course, f ⊆ g means inclusion as a set of ordered pairs or equivalently that g is a function which extends f. The restriction to monotonicity is dictated by our interest in deterministically computable functionals, which we view as given by algorithms equipped with ‘black box’ subroutines or oracles for providing values of the function arguments as needed. Thus if the oracles for f provide all the requested values in the computation of F (a, f ), then the oracles for g will provide exactly the same values and hence yield the same computation.
A functional structure is a pair A = (A, Fnl (^) A ), whare Fnl (^) A is a finite set of monotone finitary functionals on A. We consider every first-order structure A = (A, Rel (^) A , Fn (^) A , Dis (^) A ) to be also a functional structure by identifying it with the functional structure whose func- tionals are: the characteristic function χR, a functional of type (k; ), for each R ∈ Rel (^) A ; the members of Fn (^) A , which are already functionals of some type (k; ); and a constant functional of type (0; ) for each a ∈ Dis (^) A.
As examples and for future reference, we consider several more or less familiar func- tionals and functional structures.
(1) Probably the most basic example is the application or evaluation functional of type (k; k) which exercises the call to the oracle for f :
Evk,k(a, f ) f (a).
(2) Over the set ω of natural numbers we have the search functional of type (0;1):
Seω (g) ‘least’ n [g(n) 0] n ⇐⇒ g(n) 0 and (∀p < n) g(p) ↓= 0.
Here g(p) ↓= 0 is read ‘g(p) is defined and different from 0’ and means that for some q = 0, g(p) q.
(3) If H is a functional of type (k + l; · · ·), then for each a and g, λ b. H(a, b, g) denotes the function b → H(a, b, g) of type (l; ). Thus if G is of type (k; l, · · ·), then
F (a, g) G(a, λ b. H(a, b, g), g)
is of type (k; · · ·). A class F of functionals has the substitution property or is closed under substitution iff G, H ∈ F implies also F ∈ F (together with more general instances as described below). Substitution is a powerful property of a class F since it implies other closure properties. For example, if F is a class of functionals over ω with the substitution property and Seω ∈ F, then for any G ∈ F, the functional
F (m, f ) ‘least’ n [G(m, n, f ) 0] Seω (λ n. G(m, n, f ))
is also in F. In other words, F is closed under search over ω.
(4) Another nice example of a particular functional whose main importance is to join with substitution to guarantee a closure property is the primitive recursion functional over ω of type (2;1):
Primω (p, n, h)
n, if p = 0; h(Primω (p − 1 , n, h)), otherwise.
Thus if Primω , G, H, ∈ F, F is closed under substitution, and
F (p, m, f )
G(m, f ), if p = 0; H(F (p − 1 , m, f ), p, m, f ). otherwise,
then F (p, m, f ) Primω (p, G(m, f ), λ q. H(q, p, m, f )), so also F ∈ F.
(5) Let κ be a limit ordinal. The supremum functional over κ of type (1;1) is
Supκ(ρ, f ) Sup+ π<ρf (π) ν < κ ⇐⇒ (∀π < ρ) f (π) ↓< ν and (∀μ < ν)(∃π < ρ)f (π) ≥ μ.
Note that even if f is a function on κ defined for all π < ρ, Supκ(ρ, f ) is undefined when { f (π) : π < ρ } is cofinal in κ. The characteristic property of recursion over recursively regular or admissible ordinals κ is that if f is partial κ-recursive and defined for all π < ρ, then Supκ(ρ, f ) is defined. We shall see below that the usual notion of partial κ-recursion can be characterized as recursion over the functional structure (κ, Sc, 0 , <, Supκ, Seκ), where Sc is the usual successor function μ → μ + 1and
Seκ(g) ‘least’ ν [g(ν) 0] ν ⇐⇒ g(ν) 0 and (∀π < ν) g(π) ↓= 0.
(6) Let A be a transitive set of sets. The replacement functional over A of type (1;1) is
ReplA(a, f ) { f (b) : b ∈ a }A c ∈ A ⇐⇒ (∀b ∈ a)f (b) ↓∈ c and (∀d ∈ c)(∃b ∈ a)f (b) d.
2.2 Proposition. Expl (^) A is closed under argument rearrangement and expansion — that is, for any G ∈ Expl (^) A , if
F (a 0 ,... , ak− 1 , f 0 ,... , fl− 1 ) G(ai 0 ,... , aim− 1 , fj 0 ,... fjn− 1 ),
where i 0 ,... , im− 1 < k and j 0 ,... , jn− 1 < l, then also F ∈ Expl (^) A.
Proof. We illustrate the proof with an example: if G ∈ Expl (^) A and F (a, b, c, f, g) G(c, b, g), with f and g of type (k; ) and (l; ), respectively, then set
H(c, b, d, f, g) Evk,k,l 1 (Prk 2 +2 ,k,l(c, b, d, f, g),... , Prkk+2+1,k,l (c, b, d, f, g), f, g) g(d), G 0 (c, b, f, g) G(c, b, g) G(c, b, λ d. H(c, b, d, f, g)).
Then H, G 0 ∈ Expl (^) A and since
F (a, b, c, f, g) G 0 (Pr^32 ,k,l (a, b, c, f, g), Pr^31 ,k,l (a, b, c, f, g), f, g),
also F ∈ Expl (^) A.
2.3 Remark. It is easy to derive that the functionals
Cmpk,m(a, g, h 0 ,... , hm− 1 ) g(h 0 (a),... , hm− 1 (a))
and
Casesk(c, a, g, h, i)
g(a), if c = (^1) A ; h(a), if c = (^0) A ; i(a), otherwise;
are A -explicit. Conversely, any class of functionals which includes these functionals and is closed under substitution (in the form given above) is also closed under composition and definition by cases, since, for example,
G(H(a, f ), f ) Cmpk,^1 (a, λ b. G(b, f ), λ c. H(c, f )).
Although the placement of variables in the schemas for composition and substitution is precise and somewhat arbitrary, by argument rearrangement and expansion (2.2), all reasonable variations are derivable. For example, if G, H, and I are A -explicit and
F (a, b, f , g) G(a, H(a, g), λ c. I(b, c, f ), g, f ),
then also F is A -explicit. Similarly, we have closure under much more general schemas of definition by cases — for example, if G, H, I, J, and K are A -explicit (or partial A -recursive), J and K are total functions, and
F (a, f )
G(a, f ), if J(a) = (^1) A ; H(a, f ), if J(a) = (^0) A and K(a) = (^1) A ; I(a, f ), otherwise,
then also F is A -explicit. We shall use these extensions of the basic schemas without mention. In particular, we will need the following functions which are A -explicit for every A :
Not(a)
(^0) A , if a = (^1) A ; (^1) A , if a = (^0) A ;
And(a, b)
(^1) A. if a = (^1) A = b; (^0) A , if a = (^0) A or b = (^0) A ;
Or(a, b)
(^1) A. if a = (^1) A or b = (^1) A ; (^0) A , if a = (^0) A = b.
IsZero (^) A (a)
(^1) A , if a = (^0) A ; (^0) A , otherwise
IsOne (^) A (a)
(^1) A , if a = (^1) A ; (^0) A , otherwise
Note that composing these functions with total functions gives the expected result, but while
And(F (x), G(x)) ↓ ⇐⇒ F (x) ↓ and G(x) ↓,
the analogous equivalence for Or is not in general true. Indeed, we shall see in Section 7 that although the class of A -semi-recursive relations is always closed under intersection, an additional hypothesis is needed to guarantee closure under union.
2.4 Proposition. If A ′^ = (A, FnlA ′^ ), and Fnl (^) A ⊆ FnlA ′^ ⊆ Fnl (^) A ∪ Expl (^) A , then Expl (^) A = ExplA ′.
Proof. Immediate.
We introduce one other notion here for later reference:
2.5 Definition. A functional F is continuous iff whenever F (a, f ) e, there exist finite f 0 ′ ⊆ f 0 ,... , f (^) n′− 1 ⊆ fn− 1 such that also F (a, f ′) e.
2.6 Proposition. For any functional structure A , if every F ∈ Fnl (^) A is continuous, then also every F ∈ Expl (^) A is continuous.
Proof. A straightforward induction.
if R(rq 0 ,... , rqk− 1 ), go to Is, else go to It for a k-ary R ∈ Rel (^) A.
A program π for a URM (^) A of type l computes in the same way for each k a partial functional π : Ak^ × Pfl A^0 × · · · × Pfl An −^1 → A, of type (k; l). We call the resulting partial functionals A -register computable and denote the set of them by Reg (^) A.
3.1 Corollary. If Ω = (ω, Sc, =ω , 0), then the Ω-register computable functionals are exactly the partial recursive functionals.
Although the elementary parts of a theory of computability can be established for the register computable functions over any A , without further assumptions this is a rather weak notion of computability. First we have
3.2 Proposition. For any first-order structure A , Reg (^) A is closed under composition, substitution, and definition by cases. Hence all A -explicit functions are A -register com- putable.
Proof. These are all simple exercises in programming. Closure of the class of register com- putable functions under definition by cases follows easily using the conditional instruction, and closure under composition can be proved exactly as in [Cu; 2.3.1]. For substitution, consider the special case where F (a) G(a, λ b. H(a, b)). The program for G contains instructions of the form rp := h(rq 0 ,... , rql− 1 ). We construct a program for F by replacing each such instruction by the program for computing H modified to use the input of G together with rq 0 ,... , rql− 1 for its input, otherwise to use registers with indices larger than any used by G, and to store its output value in rp.
Over the natural numbers it is easy to show [Cu; 2.5.2] that the register computable functionals are also closed under search and hence include all of the partial recursive functions. The analogous result here will be that the class of register computable functions is closed under least-fixed-point recursion, as defined in the next section. We shall be able to prove this (in Section 6 below) only for structures which contain a copy of the natural numbers. Partly in preparation for this, we sketch here how to assign indices to the register computable functionals over an arbitrary first-order structure.
First, it is a standard exercise to assign G¨odel numbers (indices) to programs. Fix a primitive recursive coding 〈 m 0 ,... , mk− 1 〉 of finite sequences of natural numbers with the usual properties. Then assign numbers to URM (^) A instructions as follows:
(i) To “rp := f (rq 0 ,... , rqk− 1 )” assign the number 〈 0 , i, p, q 0 ,... , qk− 1 〉, where f is the i-th member of Fn (^) A ;
(ii) to “rp := a” assign 〈 1 , i, p 〉, where a is the i-th member of Dis (^) A ; (iii) to “rp := fj (rq 0 ,... , rqlj − 1 )” assign 〈 2 , j, p, q 0 ,... , qlj − 1 〉; (iv) to “rp := rq ” assign 〈 3 , p, q 〉; (v) to “if R(rq 0 ,... , rqk− 1 ), go to Is, else go to It” assign 〈 4 , i, q 0 ,... , qk− 1 , s, t 〉, where R is the i-th member of Rel (^) A.
Then each program π is assigned a number #(π) which is the code for the finite sequence of the numbers of its instructions. For any natural number b it is primitively recursively computable whether or not b is the number of a program for a URM (^) A , and if so the minimum possible type l. For each k, let {b}A Reg denote the empty function if b is not the number of a URM (^) A program, otherwise the functional of type (k; l) computed
by the program. Clearly
{b}A Reg : b is the number of a program
is an enumeration of
Reg (^) A. The effectiveness of the proof of the preceding proposition yields immediately
3.3 Proposition. The closure of Reg (^) A under composition, substitution, and definition by cases is effective in terms of these indices — that is, for each closure condition there is a primitive recursive function which computes an index for the resulting functional from indices of the component functionals.
4. Recursion
In this section we develop the basic properties of the class Rec (^) A of functionals recursive over an arbitrary functional structure A. The fundamental generating principle is a version of the First Recursion Theorem, which asserts the existence of computable fixed points for computable functionals.
Consider first a monotone functional I of type (k; k) over a set A. We call a k-ary partial function i a fixed point of I iff for all a ∈ A,
I(a, i) i(a).
The terminology derives from regarding I as a mapping on functions: I[i] = λ a. I(a, i). The monotonicity of I guarantees that I has, in fact, a least fixed point
I∞^ =
{ i : I[i] ⊆ i }.
Clearly if I∞^ is a fixed point at all, then it is least (under inclusion). To see that I∞ is a fixed point, note that for any i such that I[i] ⊆ i, we have by definition I∞^ ⊆ i, so by monotonicity, I[I∞] ⊆ I[i] ⊆ i. Hence, since I∞^ is the intersection of all such i, also I[I∞] ⊆ I∞. Then, again by monotonicity, I[I[I∞]] ⊆ I[I∞], so that I[I∞] is itself such an i and hence I∞^ ⊆ I[I∞]. Thus I∞^ = I[I∞].
The function I∞^ may also be described ‘from below’ by iterating I starting with the empty function. For each ordinal σ, set
I<σ^ =
τ <σ
Iτ^ and Iσ^ = I[I<σ^ ].
Thus I<^0 = ∅ and an easy induction shows that for all σ, I<σ^ ⊆ Iσ^ and that if I<σ^ = Iσ^ , then also Iσ^ = Iρ^ for all ρ > σ. Since the domain of each Iσ^ is a subset of Ak, so of power Card(A), it follows easily that I<¯σ^ = I σ¯^ for some ¯σ < Card(A)+, whence I ¯σ^ is a fixed point of I. Another straightforward induction shows that Iσ^ ⊆ I∞^ for all σ, so since I∞^ is the least fixed point of I, necessarily I σ¯^ = I∞. The least such ¯σ is called the closure ordinal of I. As an important special case we have
(iii) Rec (^) A is closed under recursion — that is, if I 0 ,... , In ∈ Rec (^) A and (I 0 ,... , In) is iterable, then I 0 ∞ = Rec(I 0 ,... , In) ∈ Rec (^) A.
4.3 Corollary. (i) Rec (^) A is closed under composition, definition by cases, and argument rearrangement and expansion;
(ii) if A ′^ = (A, FnlA ′^ ), and Fnl (^) A ⊆ FnlA ′^ ⊆ Fnl (^) A ∪ Rec (^) A , then Rec (^) A = RecA ′^.
Proof. The first two parts of (i) follow by Remark 2.3; the remainder is proved exactly as for Expl (^) A.
In classical Recursion Theory a vital role is played by various normal forms which provide a relatively simple and uniform representation for all partial recursive functions. For example, for every partial recursive function f , there is a primitive recursive function g such that f (m) ‘least’ n [g(m, n) = 0].
The key point here is that since g is primitive recursive its definition does not involve the search operator, so that the computation of f (m) cam be arranged to use only one search. The corresponding normal form here demonstrates that every partial A -recursive functional can be obtained by a single application of the operator Rec to a finite sequence of A -explicit functionals.
4.4 Definition. A functional F over A is simply partial A -recursive iff for some iterable sequence (I 0 ,... , In) of A -explicit functionals, F = I 0 ∞ = Rec(I 0 ,... , In).
The normal form may then be stated:
4.5 Theorem. Every partial A -recursive functional is simply partial A -recursive
Proof. We need to establish three facts:
(i) every A -explicit functional is simply partial A -recursive; (ii) the class of simply partial A -recursive functionals is closed under substitution; (iii) the class of simply partial A -recursive functionals is closed under recursion.
The first of these is immediate: if I is A -explicit of type (k; l), let ∗I(x, i) I(x), with ∗I of type (k; l, 0). Clearly ∗I∞^ = I and is simply partial A -recursive.
The proofs of parts (ii) and (iii) are somewhat tedious and are sketched in the Ap- pendix.
We have also the following alternative normal form.
4.6 Theorem. A functional F is partial A -recursive iff for some A -explicit functional I and some finite sequence e of the distinguished elements (^0) A and (^1) A ,
F (a, f ) I∞(a, e, f ).
Proof. Since the (constant functions with values) (^0) A and (^1) A are A -explicit, any such functional is partial A -recursive. For the converse, assume that F is partial A -recursive; by Theorem 4.5, there exists an iterable sequence (I 0 ,... , In) of A -explicit functionals such that F = I 0 ∞ = Rec(I 0 ,... , In). Each Ip (p ≤ n) has type of the form (kp + l; l, k 0 ,... , kn). Choose k > max { kp : p ≤ n } and distinct sequences e^0 ,... , en^ of the elements (^0) A and (^1) A such that each ep has length k − kp. Let ap^ denote a sequence of length kp. Then there is an A -explicit functional J such that for p ≤ n,
J(ap, ep, x, j) Ip(ap, x, j^0 ,... , jn),
where jp^ = λ ap^. j(ap, ep).
Now it is straightforward to prove by induction that
Jσ^ (ap, ep, x) Ipσ (ap, x)
so in particular F (a^0 , x) I 0 ∞ (a^0 , x) J∞(a^0 , e^0 , x)
as desired.
We conclude this section by indicating two ways to assign natural numbers as indices to the members of Rec (^) A. First we need to assign indices to the A -explicit functionals. As usual in such situations, we actually do the reverse by assigning functionals to all natural numbers regarded as codes for programs.
4.7 Definition. For and functional structure A and each b ∈ ω, we define recursively a functional [b]A^ as follows, where l = l 0 ,... , lm− 1 :
(i) [〈 0 , 〈 k, l 〉, i 〉]A^ = Prk, i l (i < k); (ii) [〈 1 , 〈 k, l 〉, j 〉]A^ = Evk, j l (j < m, lj = k); (iii) [〈 2 , 〈 k, l 〉, i 〉]A^ = the i-th member of Fnl (^) A ; (iv) [〈 3 , 〈 k, l 〉, c, d 0 ,... , dm− 1 〉]A^ = the composition of [c]A^ with [d 0 ]A^ ,... , [dm− 1 ]A^ ; (v) [〈 4 , 〈 k, l 〉, c, d 0 ,... , dm− 1 , e 〉]A^ = the substitution of [c]A^ with [d 0 ]A^ ,... , [dm− 1 ]A^ ;
(vi) [〈 5 , 〈 k + 1, l 〉, c, d , e〉]A^ = the functional defined by cases from [c]A^ , [d]A^ , and [e]A^.
In (v), the number e codes information to describe the parameter lists for the substituted functionals. In each case the assigned functional is completely undefined (the empty func- tional) if the ranks of the component parts do not match. For all other b ∈ ω, [b]A^ is the empty functional.
5. The Main Examples
Of course the first example is classical recursion over the natural numbers. We saw in Corollary 3.1that the Ω-register computable functionals coincide with the ordinary partial recursive functionals. We have also
5.1 Theorem. The class RecΩ of partial Ω-recursive functionals coincides with the usual class of partial recursive functionals over ω.
Proof. We take as our characterization of the partial recursive functionals the one of [Hi; II.3.3]: the smallest class which contains the primitive recursive functionals and is closed under composition and unbounded search.The functionals there take only total functions as arguments, but the characterization extends easily to the more general case considered here. This class surely contains the Ω-explicit functionals and is closed under substitution (see, for example, [Hi; II.3.9] and the discussion preceding it). Furthermore, by an easy extension of Kleene’s First Recursion Theorem (see [Hi; II.4.31]) this class is closed under recursion in the sense of 4.2 (iii). Hence every partial Ω-recursive functional is partial recursive.
For the opposite inclusion, it will suffice to show that the class of Ω-recursive func- tionals is closed under primitive recursion and search. By Remark 2.3, this is equivalent to showing that the two particular functionals Seω and Primω are partial Ω-recursive. For Seω , let
I(p, g, i)
0 , if g(p) 0; Sc(i(Sc(p))), if g(p) ↓= 0.
It is straightforward to prove by induction on m that
Im(p, g) n ⇐⇒ n ≤ m and g(p + n) 0 and (∀q < n)g(p + q) ↓= 0.
Hence,
I∞(p, g) n ⇐⇒ g(p + n) 0 and (∀q < n)g(p + q) ↓= 0,
and Seω (g) I∞(0, g).
Towards Primω , we note first that the predecessor function on ω is Ω-recursive:
Pred(m)
0 , if m = 0; ‘least’ n[Sc(n) = m], otherwise.
Now if we set
I(p, n, h, i)
n, if p = 0; h(i(Pred(p), n)), otherwise;
then it is straightforward to prove that Primω = I∞.
We turn next to the class of partial κ-recursive functionals for an admissible ordinal κ. There is no full treatment of computable functionals on ordinals in print, so we shall
need to be somewhat more detailed here. We start with the characterization of the partial κ-recursive functions of [Hi; VIII.1.3]. There we define a set Ωκ,κ of finite sequences of (natural numbers and) ordinals and set
{a}κ(μ) ν ⇐⇒ (a, μ, ν) ∈ Ωκ,κ.
The set Ωκ,κ is inductively defined as the smallest set containing certain tuples (a, μ, ν) which represent some simple initial functions and is closed under clauses corresponding to composition, indexing, and the functionals Supκ and Seκ. The latter, for example, takes the form
ν < κ and (b, ν, μ, 0) ∈ Ωκ,κ and (∀π < ν)(∃ξ > 0)[(b, ν, μ, ξ) ∈ Ωκ,κ] =⇒ (〈 4 , k, b 〉, μ, ν) ∈ Ωκ,κ.
It is straightforward to extend this definition to partial κ-recursive functionals. All that is required is to extend the coding of the indices to record the types of functionals and the addition of a clause for evaluating the function arguments, say
(〈 0 , k, l, 3 , j 〉, μ, f , fj (μ)) ∈ Ωκ,κ.
Now the development of [Hi; VIII.1.3–13] can be repeated essentially verbatim for the partial κ-recursive functionals.
The new results which must be established are closure of the class of partial κ-recursive functionals under substitution and recursion (in the sense of 4.2 (iii)). Closure under substitution can be established by the method of [Hi; VI.2] — one shows that there is a primitive recursive function ι such that
{ι(a, c)}κ(μ, f ) {b}(μ, λ ν^0. {c 0 }(μ, ν^0 , f ),... , λ νm−^1. {cm− 1 }(μ, νm−^1 , f )).
Note that because function arguments here are partial, none of the problems of totality which plague [Hi; VI.2] arise here.
Towards closure under recursion, let I be an iterable partial κ-recursive functional and let G be the partial κ-recursive functional defined by:
G(e, 0 , σ, μ, x) {e}κ(1, τ ∗, μ, x) G(e, 1 , σ, μ, x) I(μ, x, λ μ′^. {e}κ(0, σ, μ′, x)),
where using the selection function Selκ of [Hi; VIII.2.9] τ ∗^ τ ∗(e, σ, μ, x) is a κ-partial recursive functional such that
(∃τ < σ){e}κ(1, τ, μ, x) ↓ =⇒ τ ∗^ < σ and {e}κ(1, τ ∗, μ, x) ↓.
By the Second Recursion Theorem, choose an index ¯e such that
{ e¯}κ(i, σ, μ, x) G(¯e, i, σ, μ, x).
but a little preparation is needed to make this precise. Let L be the usual first-order lan- guage associated with A and L+^ the language obtained from L by adjoining a countable sequence of relation variables. We use letters p, q for the relation symbols of L and L+, t (with scripts) for terms, u, v, w for individual variables, and U, V, W for relation variables. The terms of L+^ are just those of L and the formulas of each language are as usual with the stipulation that the relation variables occur positively. Thus the L+-formulas com- prise the smallest class containing all atomic and negated atomic formulas of L, formulas V (t 0 ,... , tn), and closed under ∧, ∨, ∃v and ∀v.
For any l-ary partial function f over A, let Grf denote the usual (l + 1)-ary relation called the graph of f. If F is a (k; l)-ary functional over A, GrF is the second-order relation such that F (a, f ) e ⇐⇒ GrF (a, e, Grf ).
Here, Grf = Grf 0 ,...,fm− 1 = (Grf 0 ,... , Grfm− 1 ). If P is a relation on A, the semi-characteristic function of P is
χ+ P (a)
(^1) A , if P (a); ↑, otherwise.
We write χ+ P for χ+ P 0 ,... , χ+ Pl− 1.
5.3 Proposition. (i) For any A +-explicit functional F , there exists an L+-formula φF which defines GrF over A — that is,
F (a, f ) e ⇐⇒ |= A
φF [a, e, Grf ];
(ii) for any L+-formula φ, there exists an A +-explicit functional Fφ such that
A φ[a, P ] ⇐⇒ Fφ(a, χ+ P ) (^1) A ;
and in case φ has no relation variables, also
A
φ[a] ⇐⇒ Fφ(a) (^0) A.
Proof. The proof of (i) is by induction over the A +-explicit functionals and is relatively straightforward. For example, suppose
F (a, f ) G(H(a, f ), f ).
Then from φG and φH , we define φF (u, v, W ) as
∃w [φH (u, w, W ) ∧ φG(w, v, W )].
φE A (w, V ) is the formula
[w =˙ (^1) A ∧ ∃v V (v, (^1) A )] ∨ [w =˙ (^0) A ∧ ∀v V (v, (^0) A )].
To see that the class of F for which φF exists is closed under substitution, suppose
F (a, f ) G(a, λ b. H(a, b, f )) and φG and φH exist.
Then we may take for φF the result of replacing each subformula of the form W (s, t, u) of φG by φH (s, t, u) (changing bound variables if necessary to avoid collisions).
For (ii), we proceed by induction on L+-formulas. First note that for any L-term t, there is an A -explicit function Ft such that
|= A
t[a] ˙= e ⇐⇒ Ft(a) = e.
If φ is an atomic formula of L, say p(t), then set
Fφ(a) χpA (Ft(a)).
(Technically, we account for differing variables in the terms t 0 ,... , tk− 1 .) Because of the explicit inclusion of the equality on A in the structure A +, this works also for atomic equations. If φ is V (t), then
Fφ(a, f )
(^1) A , if f (Ft(a)) (^1) A ; ↑, otherwise.
Now we set recursively,
Fφ∧ψ (x) And(Fφ(x), Fψ (x)); Fφ∨ψ (x) EA(λ b. G(b, x));
where
G(b, x)
Fφ(x), if b = (^0) A Fψ (x), otherwise; F∃v φ(x) EA(λ b. Fφ(b, x)); F∀v φ(x) Not(EA(λ b. Not(Fφ(b, x)))).
To complete the picture, we need to recall from [Mo1] and [Mo2] the definitions of the A -inductive and A -hyperelementary relations. With any L+-formula φ(v 0 ,... , vk− 1 , V ), with V a k-ary relation variable, we associate a mapping Γφ : ℘(Ak) → ℘(Ak) defined by
Γφ(R) =
a ∈ Ak^ : |= A
φ[a, R]
