Recursive Functions. 6.1 Primitive Recursive Functions

Transcription

1 6 Recursive Functions The intuitive notion of an effectively computable function is the notion of a function for which there are definite, explicit rules, following which one could in principle compute its value for any given arguments. This chapter studies an extensive class of effectively computable functions, the recursively computable, or simply recursive, functions. According to Church s thesis, these are in fact all the effectively computable functions. Evidence for Church s thesis will be developed in this chapter by accumulating examples of effectively computable functions that turn out to be recursive. The subclass of primitive recursive functions is introduced in section 6.1, and the full class of recursive functions in section 6.2. The next chapter contains further examples. The discussion of recursive computability in this chapter and the next is entirely independent of the discussion of Turing and abacus computability in the preceding three chapters, but in the chapter after next the three notions of computability will be proved equivalent to each other. 6.1 Primitive Recursive Functions Intuitively, the notion of an effectively computable function f from natural numbers to natural numbers is the notion of a function for which there is a finite list of instructions that in principle make it possible to determine the value f (x 1,..., x n ) for any arguments x 1,..., x n. The instructions must be so definite and explicit that they require no external sources of information and no ingenuity to execute. But the determination of the value given the arguments need only be possible in principle, disregarding practical considerations of time, expense, and the like: the notion of effective computability is an idealized one. For purposes of computation, the natural numbers that are the arguments and values of the function must be presented in some system of numerals or other, though the class of functions that is effectively computable will not be affected by the choice of system of numerals. (This is because conversion from one system of numerals to another is itself an effective process that can be carried out according to definite, explicit rules.) Of course, in practice some systems of numerals are easier to work with than others, but that is irrelevant to the idealized notion of effective computability. For present purposes we adopt a variant of the primeval monadic or tally notation, in which a positive integer n is represented by n strokes. The variation is needed because we want to consider not just positive integers (excluding zero) but the natural numbers 63

2 64 RECURSIVE FUNCTIONS (including zero). We adopt the system in which the number zero is represented by the cipher 0, and a natural number n > 0 is represented by the cipher 0 followed by a sequence of n little raised strokes or accents. Thus the numeral for one is 0, the numeral for two is 0, and so on. Two functions that are extremely easy to compute in this notation are the zero function, whose value z(x) is the same, namely zero, for any argument x, and the successor function s(x), whose value for any number x is the next larger number. In our special notation we write: z(0) = 0 z(0 ) = 0 z(0 ) = 0 s(0) = 0 s(0 ) = 0 s(0 ) = 0 To compute the zero function, given any any argument, we simply ignore the argument and write down the symbol 0. To compute the successor function in our special notation, given a number written in that notation, we just add one more accent at the right. Some other functions it is easy to compute (in any notation) are the identity functions. We have earlier encountered also the identity function of one argument, id or more fully id 1 1, which assigns to each natural number as argument that same number as value: id 1 1 (x) = x. There are two identity functions of two arguments: id 2 1 and id2 2. For any pair of natural numbers as arguments, these pick out the first and second, respectively, as values: id 2 1 (x, y) = x id2 2 (x, y) = y. In general, for each positive integer n, there are n identity functions of n arguments, which pick out the first, second,..., and nth of the arguments: id n i (x 1,...,x i,...,x n ) = x i. Identity functions are also called projection functions. [In terms of analytic geometry, id 2 1 (x, y) and id2 2 (x, y) are the projections x and y of the point (x, y) to the X-axis and to the Y-axis respectively.] The foregoing functions zero, successor, and the various identity functions are together called the basic functions. They can be, so to speak, computed in one step, at least on one way of counting steps. The stock of effectively computable functions can be enlarged by applying certain processes for defining new functions from old. A first sort of operation, composition, is familiar and straightforward. If f is a function of m arguments and each of g 1,..., g m is a function of n arguments, then the function obtained by composition from f, g 1,..., g m is the function h where we have h(x 1,...,x n ) = f (g 1 (x 1,...,x n ),...,g m (x 1,...,x n )) (Cn)

3 One might indicate this in shorthand: 6.1. PRIMITIVE RECURSIVE FUNCTIONS 65 h = Cn[ f, g 1,...,g m ]. Composition is also called substitution. Clearly, if the functions g i are all effectively computable and the function f is effectively computable, then so is the function h. The number of steps needed to compute h(x 1,...,x n ) will be the sum of the number of steps needed to compute y 1 = g 1 (x 1,...,x n ), the number needed to compute y 2 = g 2 (x 1,...,x n ), and so on, plus at the end the number of steps needed to compute f (y 1,...,y m ). 6.1 Example (Constant functions). For any natural number n, let the constant function const n be defined by const n (x) = n for all x. Then for each n, const n can be obtained from the basic functions by finitely many applications of composition. For, const 0 is just the zero function z, and Cn[s, z] is the function h with h(x) = s(z(x)) = s(0) = 0 = 1 = const 1 (x) for all x, so const 1 = Cn[s, z]. (Actually, such notations as Cn[s, z] are genuine function symbols, belonging to the same grammatical category as h, and we could have simply written Cn[s, z](x) = s(z(x)) here rather than the more longwinded if h = Cn[s, z], then h(x) = z(x).) Similarly const 2 = Cn[s, const 1 ], and generally const n+1 = Cn[s, const n ]. The examples of effectively computable functions we have had so far are admittedly not very exciting. More interesting examples are obtainable using a different process for defining new functions from old, a process that can be used to define addition in terms of successor, multiplication in terms of addition, exponentiation in terms of multiplication, and so on. By way of introduction, consider addition. The rules for computing this function in our special notation can be stated very concisely in two equations as follows: x + 0 = x x + y = (x + y). To see how these equations enable us to compute sums consider adding 2 = 0 and 3 = 0. The equations tell us: = (0 + 0 ) by 2nd equation with x = 0 and y = = (0 + 0 ) by 2nd equation with x = 0 and y = = (0 + 0) by 2nd equation with x = 0 and y = = 0 by 1st equation with x = 0. Combining, we have the following: = (0 + 0 ) = (0 + 0 ) = (0 + 0) = 0. So the sum is 0 = 5. Thus we use the second equation to reduce the problem of computing x + y to that of computing x + z for smaller and smaller z, until we arrive at z = 0, when the first equation tells us directly how to compute x + 0.

4 66 RECURSIVE FUNCTIONS Similarly, for multiplication we have the rules or equations x 0 = 0 x y = x + (x y) which enable us to reduce the computation of a product to the computation of sums, which we know how to compute: 0 0 = 0 + (0 0 ) = 0 + (0 + (0 0 )) = 0 + (0 + (0 + (0 0))) = 0 + (0 + (0 + 0)) = 0 + (0 + 0 ) after which we would carry out the computation of the sum in the last line in the way indicated above, and obtain 0. Now addition and multiplication are just the first two of a series of arithmetic operations, all of which are effectively computable. The next item in the series is exponentiation. Just as multiplication is repeated addition, so exponentiation is repeated multiplication. To compute x y, that is, to raise x to the power y, multiply together yxs as follows: x x x x (a row of yxs). Conventionally, a product of no factors is taken to be 1, so we have the equation For higher powers we have x 0 = 0. x 1 = x x 2 = x x. x y = x x x x y+1 = x x x x = x x y So we have the equation (a row of yxs) (a row of y + 1 xs). x y = x x y. Again we have two equations, and these enable us to reduce the computation of a power to the computation of products, which we know how to do. Evidently the next item in the series, super-exponentiation, would be defined as follows: x x xx... (a stack of yxs). The alternative notation x y may be used for exponentiation to avoid piling up of superscripts. In this notation the definition would be written as follows: x x x... x (a row of yxs).

5 6.1. PRIMITIVE RECURSIVE FUNCTIONS 67 Actually, we need to indicate the grouping here. It is to the right, like this: and not to the left, like this: x (x (x... x...)) (...((x x) x)...) x. For it makes a difference: 3 (3 3) = 3 (27) = ; while (3 3) 3 = 27 3 = Writing x y for the super-exponential, the equations would be x 0 = 0 x y = x (x y). The next item in the series, super-duper-exponentiation, is analogously defined, and so on. The process for defining new functions from old at work in these cases is called (primitive) recursion. As our official format for this process we take the following: h(x, 0) = f (x), h(x, y ) = g(x, y, h(x, y)) (Pr). Where the boxed equations called the recursion equations for the function h hold, h is said to be definable by (primitive) recursion from the functions f and g. In shorthand, h = Pr[ f, g]. Functions obtainable from the basic functions by composition and recursion are called primitive recursive. All such functions are effectively computable. For if f and g are effectively computable functions, then h is an effectively computable function. The number of steps needed to compute h(x, y) will be the sum of the number of steps needed to compute z 0 = f (x) = h(x, 0), the number needed to compute z 1 = g(x, 0, z 0 ) = h(x, 1), the number needed to compute z 2 = g(x, 1, z 1 ) = h(x, 2), and so on up to z y = g(x, y 1, z y 1 ) = h(x, y). The definitions of sum, product, and power we gave above are approximately in our official boxed format. [The main difference is that the boxed format allows one, in computing h(x, y ), to apply a function taking x, y, and h(x, y) as arguments. In the examples of sum, product, and power, we never needed to use y as an argument.] By fussing over the definitions we gave above, we can put them exactly into the format (Pr), thus showing addition and multiplication to be primitive recursive. 6.2 Example (The addition or sum function). We start with the definition given by the equations we had above, x + 0 = x x + y = (x + y). As a step toward reducing this to the boxed format (Pr) for recursion, we replace the ordinary plus sign, written between the arguments, by a sign written out front: sum(x, 0) = x sum(x, y ) = sum(x, y).

6 68 RECURSIVE FUNCTIONS To put these equations in the boxed format (Pr), we must find functions f and g for which we have f (x) = x g(x, y, ) = s( ) for all natural numbers x, y, and. Such functions lie ready to hand: f = id 1 1, g = Cn [s, id 3 3 ]. In the boxed format we have sum(x, 0) = id 1 1 (x) sum(x, s(y)) = Cn[ s, id 3 3] (x, y, sum(x, y)) and in shorthand we have sum = Pr [ id 1 1, Cn[ s, id 3 3]]. 6.3 Example (The multiplication or product function). We claim prod = Pr[z, Cn[sum, id 3 1, id3 3 ]]. To verify this claim we relate it to the boxed formats (Cn) and (Pr). In terms of (Pr) the claim is that the equations prod(x, 0) = z(x) prod(x, s(y)) = g(x, y, prod(x, y)) hold for all natural numbers x and y, where [setting h = g, f = sum, g 1 = id 3 1, g 2 = id 3 3 in the boxed (Cn) format] we have g(x 1, x 2, x 3 ) = Cn [ sum, id 3 1, id3 3] (x1, x 2, x 3 ) = sum ( id 3 1 (x 1, x 2, x 3 ), id 3 3 (x 1, x 2, x 3 ) ) = x 1 + x 3 for all natural numbers x 1, x 2, x 3. Overall, then, the claim is that the equations prod(x, 0) = z(x) prod(x, s(y)) = x + prod(x, y) hold for all natural numbers x and y, which is true: x 0 = 0 x y = x + x y. Our rigid format for recursion serves for functions of two arguments such as sum and product, but we are sometimes going to wish to use such a scheme to define functions of a single argument, and functions of more than two arguments. Where there are three or more arguments x 1,..., x n, y instead of just the two x, y that appear in (Pr), the modification is achieved by viewing each of the five occurrences of x in the boxed format as shorthand for x 1,..., x n. Thus with n = 2 the format is h(x 1, x 2, 0) = f (x 1, x 2 ) h(x 1, x 2, s(y)) = g(x 1, x 2, y, h(x 1, x 2, y)). 6.4 Example (The factorial function). The factorial x! for positive x is the product x of all the positive integers up to and including x, and by convention 0! = 1. Thus we have 0! = 1 y! = y! y.

7 6.1. PRIMITIVE RECURSIVE FUNCTIONS 69 To show this function is recursive we would seem to need a version of the format for recursion with n = 0. Actually, however, we can simply define a two-argument function with a dummy argument, and then get rid of the dummy argument afterwards by composing with an identity function. For example, in the case of the factorial function we can define dummyfac(x, 0) = const 1 (x) dummyfac(x, y ) = dummyfac(x, y) y so that dummyfac(x, y) = y! regardless of the value of x, and then define fac(y) = dummyfac (y, y). More formally, fac = Cn [ Pr [ const 1, Cn [ prod, id 3 3, Cn[ s, id 3 2]]], id, id ]. (We leave to the reader the verification of this fact, as well as the conversions of informalstyle definitions into formal-style definitions in subsequent examples.) The example of the factorial function can be generalized. 6.5 Proposition. Let f be a primitive recursive function. Then the functions are primitive recursive. g(x, y) = f (x, 0) + f (x, 1) + + f (x, y) = h(x, y) = f (x, 0) f (x, 1) f (x, y) = Proof: We have for the g the recursion equations and similarly for h. g(x, 0) = f (x, 0) g(x, y ) = g(x, y) + f (x, y ) y f (x, i) i=0 y f (x, i) Readers may wish, in the further examples to follow, to try to find definitions of their own before reading ours; and for this reason we give the description of the functions first, and our definitions of them (in informal style) afterwards. 6.6 Example. The exponential or power function. 6.7 Example (The (modified) predecessor function). Define pred (x) to be the predecessor x 1 of x for x > 0, and let pred(0) = 0 by convention. Then the function pred is primitive recursive. 6.8 Example (The (modified) difference function). Define x. y to be the difference x y if x y, and let x. y = 0 by convention otherwise. Then the function. is primitive recursive. 6.9 Example (The signum functions). Define sg(0) = 0, and sg(x) = 1 if x > 0, and define sg(0) = 1 and sg(x) = 0 if x > 0. Then sg and sg are primitive recursive. i=0

8 70 RECURSIVE FUNCTIONS Proofs Example 6.6. x 0 = 1, x s(y) = x (x y), or more formally, exp = Pr [ Cn[s, z], Cn [ prod, id 3 1, id3 3]]. Example 6.7. pred(0) = 0, pred(y ) = y. Example 6.8. x. 0 = x, x. y = pred(x. y). Example 6.9. sg(y) = 1. (1. y), sg(y) = 1. y. 6.2 Minimization We now introduce one further process for defining new functions from old, which can take us beyond primitive recursive functions, and indeed can take us beyond total functions to partial functions. Intuitively, we consider a partial function f to be effectively computable if a list of definite, explicit instructions can be given, following which one will, in the case they are applied to any x in the domain of f, arrive after a finite number of steps at the value f (x), but following which one will, in the case they are applied to any x not in the domain of f, go on forever without arriving at any result. This notion applies also to two- and many-place functions. Now the new process we want to consider is this. Given a function f of n + 1 arguments, the operation of minimization yields a total or partial function h of n arguments as follows: y if f (x 1,...,x n, y) = 0, and for all t < y Mn[ f ](x 1,...,x n ) = f (x 1,...,x n, t) is defined and 0 undefined if there is no such y. If h = Mn[ f ] and f is an effectively computable total or partial function, then h also will be such a function. For writing x for x 1,..., x n, we compute h(x) by successively computing f (x, 0), f (x, 1), f (x, 2), and so on, stopping if and when we reach a y with f (x, y) = 0. If x is in the domain of h, there will be such a y, and the number of steps needed to compute h(x) will be the sum of the number of steps needed to compute f (x, 0), the number of steps needed to compute f (x, 1), and so on, up through the number of steps needed to compute f (x, y) = 0. If x is not in the domain of h, this may be for either of two reasons. On the one hand, it may be that all of f (x, 0), f (x, 1), f (x, 2),...are defined, but they are all nonzero. On the other hand, it may be that for some i, all of f (x, 0), f (x, 1),..., f (x, i 1) are defined and nonzero, but f (x, i) is undefined. In either case, the attempt to compute h(x) will involve one in a process that goes on forever without producing a result. In case f is a total function, we do not have to worry about the second of the two ways in which Mn[ f ] may fail to be defined, and the above definition boils down to the following simpler form. the smallest y for which Mn[ f ](x 1,...,x n ) = f (x 1,...,x n, y) = 0 if such a y exists undefined otherwise.

9 PROBLEMS 71 The total function f is called regular if for every x 1,..., x n there is a y such that f (x 1,..., x n, y) = 0. In case f is a regular function, Mn[ f ] will be a total function. In fact, if f is a total function, Mn[ f ] will be total if and only if f is regular. For example, the product function is regular, since for every x, x 0 = 0; and Mn[prod] is simply the zero function. But the sum function is not regular, since x + y = 0 only in case x = y = 0; and Mn[sum] is the function that is defined only for 0, for which it takes the value 0, and undefined for all x > 0. The functions that can be obtained from the basic functions z, s, id n i by the processes Cn, Pr, and Mn are called the recursive (total or partial) functions. (In the literature, recursive function is often used to mean more specifically recursive total function, and partial recursive function is then used to mean recursive total or partial function.) As we have observed along the way, recursive functions are all effectively computable. The hypothesis that, conversely, all effectively computable total functions are recursive is known as Church s thesis (the hypothesis that all effectively computable partial functions are recursive being known as the extended version of Church s thesis). The interest of Church s thesis derives largely from the following fact. Later chapters will show that some particular functions of great interest in logic and mathematics are nonrecursive. In order to infer from such a theoretical result the conclusion that such functions are not effectively computable (from which may be inferred the practical advice that logicians and mathematicians would be wasting their time looking for a set of instructions to compute the function), we need assurance that Church s thesis is correct. At present Church s thesis is, for us, simply an hypothesis. It has been made somewhat plausible to the extent that we have shown a significant number of effectively computable functions to be recursive, but one can hardly on the basis of just these few examples be assured of its correctness. More evidence of the correctness of the thesis will accumulate as we consider more examples in the next two chapters. Before turning to examples, it may be well to mention that the thesis that every effectively computable total function is primitive recursive would simply be erroneous. Examples of recursive total functions that are not primitive recursive are described in the next chapter. Problems 6.1 Let f be a two-place recursive total function. Show that the following functions are also recursive: (a) g(x, y) = f (y, x) (b) h(x) = f (x, x) (c) k 17 (x) = f (17, x) and k 17 (x) = f (x, 17). 6.2 Let J 0 (a, b) be the function coding pairs of positive integers by positive integers that was called J in Example 1.2, and from now on use the name J for the corresponding function coding pairs of natural numbers by natural numbers, so that J(a, b) = J 0 (a + 1, b + 1) 1. Show that J is primitive recursive.

10 72 RECURSIVE FUNCTIONS 6.3 Show that the following functions are primitive recursive: (a) the absolute difference x y, defined to be x y if y < x, and y x otherwise. (b) the order characteristic, χ (x, y), defined to be 1 if x y, and 0 otherwise. (c) the maximum max(x, y), defined to be the larger of x and y. 6.4 Show that the following functions are primitive recursive: (a) c(x, y, z) = 1 if yz = x, and 0 otherwise. (b) d(x, y, z) = 1 if J(y, z) = x, and 0 otherwise. 6.5 Define K (n) and L(n) as the first and second entries of the pair coded (under the coding J of the preceding problems) by the number n, so that J(K (n), L(n)) = n. Show that the functions K and L are primitive recursive. 6.6 An alternative coding of pairs of numbers by numbers was considered in Example 1.2, based on the fact that every natural number n can be written in one and only one way as 1 less than a power of 2 times an odd number, n = 2 k(n) (2l(n). 1). 1. Show that the functions k and l are primitive recursive. 6.7 Devise some reasonable way of assigning code numbers to recursive functions. 6.8 Given a reasonable way of coding recursive functions by natural numbers, let d(x) = 1 if the one-place recursive function with code number x is defined and has value 0 for argument x, and d(x) = 0 otherwise. Show that this function is not recursive. 6.9 Let h(x, y) = 1 if the one-place recursive function with code number x is defined for argument y, and h(x, y) = 0 otherwise. Show that this function is not recursive.