The decidable properties of subrecursive functions

What can be decided or semidecided about a primitive recursive function, given a deﬁnition of that function by primitive recursion? What about subrecursive classes other than primitive recursive functions? We provide a complete and explicit characterization of the decidable and semidecidable properties. This characterization uses a variant of Kolmogorov complexity where only programs in a subrecursive programming language are allowed. More precisely, we prove that all the decidable and semidecidable properties can be obtained as combinations of two classes of basic decidable properties: (i) the function takes some particular values on a ﬁnite set of inputs, and (ii) every ﬁnite part of the function can be compressed to some extent


Introduction
What can be decided about a function f : N → N if f is represented by a program computing it?What can be semidecided?
In the 50's, many computability theory results have been proved in order to answer these questions.The answers depend on the class of functions considered.

Partial computable functions.
For the class of partial computable functions, Rice [11] proved that no non-trivial property is decidable, and Shapiro [12] refined it by characterizing the semidecidable properties.These results show that having a program computing f does not give more information than having an oracle giving the values of f , in the sense that the two presentations induce the same classes of decidable and semidecidable properties.In other words, the only way of exploiting a program computing f is to execute it on any input to obtains the values of f .Hence the code of the program contains no more information than a black-box containing the program.

Total computable functions.
For the class of total computable functions, Kreisel, Lacombe, Shoenfield [8] and independently Ceitin [2] characterized the decidable properties.Again they are the same whether the function is presented by a program or by an oracle.
However, Friedberg [4] showed that the semidecidable properties of total computable functions do not admit such a characterization.In that case, having a program computing f gives more information than having the values of f .In [6] we proved that the extra information is simply the size of the program.A remaining open problem is to obtain a nice characterization of the semidecidable properties of total computable functions, when they are presented by programs.

Subrecursive classes.
In this paper we investigate the case of a subrecursive class, i.e. a class of total computable functions that can be effectively enumerated.Examples of such classes are the primitive recursive functions, complexity classes such as FPTIME, or the class of provably total functions in Peano Arithmetic.Here the function in the class is presented by a program in a restricted programming language.As for the whole class of total computable functions, the semidecidable properties are not the same if the function is presented by an oracle.However we obtain a characterization of the semidecidable properties, when the function is presented by a subrecursive program.This characterization uses a version of Kolmogorov complexity restricted to a subrecursive programming language.This is the main result of the paper.
We also prove that the semidecidable properties of total computable functions do not admit an analogous characterization.
We also discuss the difference between having an oracle giving the values of a function, and a black-box containing a program computing that function.The difference is that no assumption is made on the time it takes for the oracle to answer, while a program in a blackbox has particular halting times.We show that in general it does not make any difference, but we also show a situation where the halting times of the black-box can be exploited.

Notations.
Let N * be the set of finite sequences of natural numbers and N N the Baire space of functions from N to N. Given f ∈ N N and n ∈ N, f n denotes the finite sequence (f (0), . . ., f (n−1)) ∈ set of all extensions of v and call it a cylinder.The Baire space is endowed with the topology whose open sets are unions of cylinders.An effective open set is the union of a computable sequence of cylinders.

Decidable and semidecidable properties
In this paper, a subrecursive class of functions is simply a class C of total computable functions that can be computably enumerated: there is a numbering

function may have several indices
).There are usually many ways of indexing such a class, and they may induce different decidable properties.A thorough investigation about indexings of subrecursive classes can be found in [7].
Examples of subrecursive classes are: the primitive recursive functions, the class FPTIME of polynomial-time computable functions, the class of provably total computable functions in Peano arithmetic.A numbering of a class can be obtained from a numbering of the programs in a subrecursive programming language, or a restricted model of computation.Hence having an index of a function is usually equivalent to having a program for that function, in the restricted language.Famous examples of restricted programming language are: definitions by primitive recursion, LOOP programming language [10], polynomially clocked Turing machines, proofs of totality in Peano Arithmetic.
Observe that two programming languages admitting computable translation procedures in both directions induce the same decidable and semidecidable properties.This is for instance the case of definitions by primitive recursion and LOOP programs.
Let A ⊆ C .First observe that the property f ∈ A is semidecidable given f by an oracle exactly when A is the intersection of an effective open subset of the Baire space with C .Indeed, when the machine semideciding f ∈ A accepts f in finite time so it has only read a finite segment of f hence it will accept all functions in some cylinder [f n ].The property f ∈ A is decidable given f by an oracle exactly when both A and C \ A are the intersections of effective open sets with C .
The goal of this paper is to obtain a similar understanding of the decidable and semidecidable sets A ⊆ C , when f ∈ C is presented by a C -index rather than an oracle.
In order to investigate this problem we introduce a notion of Kolmogorov complexity adapted to the class C .
) is nondecreasing and converges to K C (f ) (which may be infinite).By the assumptions on C , the quantity K C (v) is computable from v (when it is finite -in, general, the predicate K C (v) = i is decidable), contrary to usual Kolmogorov complexity which is upper semicomputable only.However K C usually does not belong to the class C (modulo encoding of N * in N).
It may seem more consistent with usual notions of Kolmogorov complexity (see e.g.[9]) to take for instance log(i) instead of i in the definition, or to use a machine that is universal for the class C and define K C in terms of the size of its inputs.All these choices are equally acceptable and lead exactly to the same result.The important point is that for each such notion of complexity K , an upper bound on K C (f ) can be uniformly computed from any upper bound on K (f ) and vice-versa.Here we take the simplest definition of complexity following directly from the enumeration of C , to avoid technicality.

An index gives more information than an oracle
Kreisel-Lacombe-Shoenfield/Ceitin's theorem implies that the properties of total computable functions that are decidable from indices are also decidable from oracles.In essence, Rice's theorem states the same for the class of partial computable functions.In general the situation is different when restricting to some subrecursive class: there exist properties that are decidable from indices but not from oracles.
Let us first give a concrete class of such properties.A computable order is a nondecreasing unbounded computable function h : N → N, such as log(n) , n 2 or 2 n for instance.Definition 2.2.Let C be a subrecursive class of functions and h a computable order.We define the set A C ,h of (C , h)-anticomplex functions as We borrow the terminology from [3], where the notion of anti-complex set is defined in terms of usual Kolmogorov complexity, and is studied from a computability-theoretic perspective.
Proposition 2.1.For f ∈ C , the property f ∈ A C ,h is decidable given any C -index of f .Proof.Given an index i for f , one has for all n such that h(n) < i.This property is decidable as K C (f n ) is computable from i and n and only a finite number of values of n has to be checked.
Note that it is important that h be unbounded.One can easily show that if for each g ∈ C the set {j ∈ N : f j = g} is not decidable (usual subrecursive classes satisfy this condition), then when h is bounded the property f ∈ A C ,h is not decidable given any C -index of f .
In general A C ,h is no more decidable if instead of an index of f one is only given f as oracle.
Proposition 2.2.If C is dense in N N then A C ,h has empty interior in C (i.e.does not contain the intersection of a cylinder with C ), therefore A C ,h is not semidecidable when the input function is given as oracle.
Proof.For each u = (u 0 , . . ., u n−1 ) ∈ N * , there exist only finitely many All the usual subrecursive classes are dense in N N .Observe that in computational complexity theory, one is more often interested in classes of problems rather than functions.Hence C could be the class of characteristic functions of subsets of N in some complexity class, such as P. In that case, C is not dense in N N , however it is dense in {0, 1} N and a similar result holds.
Proposition 2.3.The same result holds if C is dense in {0, 1} N and h is sufficiently small.
Proof.Let g be a computable order such that the number of finite sequences v such that K C (v) ≤ k is bounded by g(k).If K C is the notion of complexity from Definition 2.1 then one can take g(k) = k + 1.For other notions of complexity based on length of binary programs, one could take g(k) = 2 k+1 instead.
Let h be a computable order such that g The result does not hold for any class C : if C is the class of constant functions, numbered in the obvious way, then having an oracle for f ∈ C is equivalent to having a C -index of f .This class has the particular property that all the functions in C are isolated from each other and as we now show this is the only obstruction to generalizing Propositions 2.2 and 2.3.We recall that a function f is not isolated in C if for each p ∈ N there exists some g = f in C such that g p = f p .Proposition 2.4.If C contains a function f that is not isolated in C then there is a computable order h such that f belongs to A C ,h but not to its interior, therefore A C ,h is not semidecidable when the input function is given as oracle.
Hence having an index for f ∈ C usually gives more information than having an access to f via an oracle, as it enables to decide more properties of f .What is the additional information?Having an index for f obviously bounds K C (f ), and we now show that in a sense this is the only additional information.
First observe that the proof of Proposition 2.1 actually shows that A C ,h remains decidable if one is given f via an oracle together with an upper bound on K C (f ).This is the case of every decidable, and even semidecidable property.Proposition 2.5.Let A ⊆ C be such that the problem f ∈ A is semidecidable given a C -index of f .Then the problem f ∈ A is semidecidable given an access to f as oracle together with any upper bound on K C (f ).
Proof.Given f and k ≥ K C (f ), one can progressively reject all numbers i ≤ k such that f i = f .In parallel one can progressively accept all numbers i ≤ k that are accepted by the semidecision procedure for A. Wait for a stage when every number i ≤ k is accepted or rejected.If this happens then accept f .

If one defines
Indeed, U k is defined as the union of finite prefixes of oracles f read and accepted by the machine semideciding A, given k as upper bound on K C (f ).
It was proved in [6] that such a result also holds for the class of total computable functions and much more general classes of computable objects.The proof given here in the case of a subrecursive class C is much easier because we only deal with total programs (every f i is total, so one can always recognize whether f i = f ).

The main result
We can now state our main result: the cylinders and the sets of anticomplex functions are the basic decidable properties, from which all decidable and semidecidable properties can be obtained.
for some computable sequences of finite words v i ∈ N * and orders h i : N → N.
Proof.We prove that 1. implies 2., the other direction being a direct consequence of Proposition 2.1.We slightly reformulate the property A C ,h , using the following sets.Recall the sets C k = {f i : i ≤ k} defined after Proposition 2.5.For k, n ∈ N let Observe that f ∈ A C ,h if and only if f ∈ C n h(n) for all n.Assume that condition 1. in the statement of the theorem holds.By Proposition 2.5 there exist uniformly effective open sets In order to obtain the announced families v i and h i to cover the whole set A, we will simply start from all possible k ∈ N and all v in the effective enumeration of U k+1 .
We now define h, by first constructing a kind of inverse of h.More precisely we define a computable increasing sequence n i such that for all i, The base case i = 0 is satisfied as The left-hand side is a finite set.For each f in that set, there is n ∈ N such that [f n ] ⊆ U k+i+2 .As the set is finite there is a single n that works for each f in the finite set.As this finite set is computable, such a n can be computed.We then define n i+1 > n i such that We then have Let h be the computable order defined by h(n) = k + min{i ≥ 1 : n ≤ n i }.We claim, as announced, that The first inequality is straightforward: To prove the second inequality, observe that if

and then use (1).
A set A ⊆ C is then decidable from C -indices if and only if both A and C \ A can be expressed as effective unions of sets [v] ∩ A C ,h .

A further question.
Each effective numbering of a class C induces particular classes of decidable and semidecidable properties.What can be said about the properties that are decidable or semidecidable for every effective numbering of C ?The least we can say is that any property of total functions that is Markov decidable, i.e. decidable given an arbitrary index of the total function, is also decidable for every effective numbering of C (see next section for more information about Markov computability), and similarly for semidecidable properties.Does the converse also holds?In a sequel to this paper we will show that it does not: in reasonable subrecursive classes, there exists a property that cannot be semidecided from arbitrary indices, but is semidecidable in any effective total numbering of the class.

The whole class of total computable functions
By the Kreisel-Lacombe-Shoenfield/Ceitin theorem, the properties of total computable functions that are Markov decidable, i.e., decidable from indices coincide with the ones that are decidable from oracles, hence are generated by cylinders.However Friedberg showed that is it not the case for Markov semidecidable properties.Can we obtain a characterization of these properties as in the case of subrecursive classes?
We leave this problem open, but we show that the analog of Theorem 2.3 does not hold.We first introduce the analog of Definition 2.2.Here, ϕ i is some Gödel numbering of the partial computable functions.
Let h be a computable order.We define the set A h of h-anticomplex functions as Again, the property f ∈ A h is semi-decidable (but this time not decidable) from any index of the total computable function f , but it is not semidecidable if f is given by an oracle.Observe that in the definition of K(v), one considers all partial computable functions extending v.A direct analog of Definition 2.1 would be to consider total functions only.However the resulting anticomplexity property would not be semidecidable.
We now prove that the sets of anticomplex functions do not generate all the semidecidable properties.

Theorem 2.5. There is a semidecidable property of total computable functions that does not contain any non-empty set [v] ∩ A h .
Proof.Let t(j, i) be a partial computable function such that if ϕ j is total then t(j, i) is defined for all i.Define the set where [ϕ j t(j,i) ] is empty if t(j, i) is not defined or ϕ j is not defined on the first t(j, i) inputs.The property f ∈ B is semidecidable from indices of f .Indeed, if ϕ i is total then We now take t(j, i) to be the halting time of ϕ j (i) plus i + 1.We prove that the corresponding set B does not contain any non-empty set [v]∩A h .Let h be some computable order.We want to build a function Proof.The idea is simply that for a, b, m ∈ N, if [ϕ a m ] \ B b is non-empty then it contains a function whose complexity can be controlled.Indeed, while such a function cannot be effectively found as the set B b is only enumerable, it becomes possible if some extra bits of information about B b are provided.
Consider an algorithm that on inputs a, b, M and p ≤ b+1 tries to find a set L ⊆ {0, . . ., b} of p elements such that for all j ∈ L, ϕ j t(j,b) is defined, tests whether [ϕ a M ]\ j∈L [ϕ j t(j,b) ] is non-empty and if it is so computes some total function f in that set (p is a guess about the number of cylinders in B b ).
The complexity of the output of the algorithm can be bounded in terms of the complexity of its inputs: there is a total computable function m 0 (a, b, e) such that if M := ϕ e (a, b) is defined and p ≤ b + 1 and the algorithm finds a function f , then K(f ) ≤ m 0 (a, b, e).We can now conclude.

Claim 1. ϕ a
In other words, the complement of B is "so big" that its intersection with each A h is dense in A h .
We conjecture than there is no way of describing the semidecidable properties of total computable functions, using a parametrization by total computable functions.We say that a set W is extensional if when ϕ i = ϕ j is total and i ∈ W , one has j ∈ W .An extensional c.e. set W represents the semidecidable property {ϕ i : i ∈ W and ϕ i is total}.Let Tot = {i : ϕ i is total}.
Conjecture.There is no computable function h : Tot → N such that For all i ∈ Tot, W h(i) is extensional, Every semidecidable property is represented by some W h(i) with i ∈ Tot.

3
Black-box or oracle?
In computer science one often makes the distinction between accessing a program via its code, or as a black-box.For instance, this distinction appears naturally when validating or evaluating the correctness of a program, either by proving that its code is correct, or testing its outputs on a bunch of inputs, without looking at its code.
As for programs of every day life, looking at the code usually gives much more information than looking at its outputs.What about the general case of arbitrary programs, where information can be obfuscated?What is the difference between reading the code of a program and running it as a black-box?Does one obtain the same information about the function it computes?What additional information does the code of a program contains, compared to a black-box containing the program?
The results presented here (e.g., Proposition 2.5) and in [6] may be seen as answers to these questions.However, strictly speaking our results involve oracles more than black-boxes, the difference being that a black-box hides an actual program while no assumption is put on an arbitrary oracle.Does it make a difference?Does a black-box containing a program computing a function f give more information about f than an arbitrary oracle for f ?For instance, could the particular halting times of the program (measurable from outside the black-box) be exploited in some way?
In this section we present a few results that are partial answers to these questions.
We first prove a result suggesting that a black-box does not give more information than an arbitrary oracle.

Observing a Turing machine
Here we prove that if the program is a Turing machine and that we can observe its execution, without knowing the complete transition table, we do not have more information than from an oracle giving the outputs of the machine.
Observing the execution of the machine means that at each step one can see the configuration of the machine, i.e. the contents of the tapes, the positions of the heads and the internal state.However, one may never know the complete transition table and the number of states.Equivalently, the observer progressively obtains the content of the transition table (at least its reachable part), but if the table is incomplete he may never know it entirely.
More formally, let us assume that the set Q of states of a Turing machine is a subset of N, but is not known by the observer.Σ is some known finite alphabet.Instead of having access to the transition table δ as a finite function from Q × Σ to Q × Σ × {←, ↓, →}, the observer has access to δ as a partial function from N × Σ → N × Σ × {←, ↓, →}, defined on Q × Σ only.In particular no upper bound on the elements of Q is known.
Theorem 3.1.Let A be a set of total computable functions.The following are equivalent:

The problem f ∈ A is semidecidable given an enumeration of a transition table of a
Turing machine computing f , 2. The problem f ∈ A is semidecidable given an oracle for f .Proof.The intuition is as follows.Assume that 1. holds.Given a total computable function f , there is a machine that outputs the same values as f on inputs 0, . . ., n for some n, such that its transition table is accepted by the semidecision procedure and can be extended to the transition table of a machine computing g, for any g that coincides with f on 0, . . ., n.As a result, the cylinder [f n ] is contained in A, which is open (and even effectively open).
Let E ⊆ N be a noncomputable c.e. set.The following claim is obvious.
Claim 3. Given i, one can effectively build a machine M i such that on input n, M i (n) halts on the same configuration as the initial one (in particular its input tape contains n), except that its state is q 1 if i is enumerated in E by stage n, q 0 otherwise.q 0 and q 1 are never reached before and there is no transition from these states.
Let N be a Turing machine with initial state q 0 , all the other states being fresh (no common state with the machines M i ).Think of N as computing a total function f , but we do not need to assume that N is total.Claim 4. For each i one can effectively build a Turing machine, denoted We now prove that A is the intersection of an effective open set U with the class of total computable functions, which is equivalent to 2. in the statement of Theorem 3.1.For each machine N , look for i ∈ E such that an enumeration of N • M i is accepted by the semidecision procedure.Compute n 0 such that i is enumerated in E at stage n 0 .If N is defined on inputs 0, . . ., n 0 −1, with output values v 0 , . . ., v n0−1 respectively then enumerate the cylinder [v 0 , . . ., v n0−1 ] in U .Claim 5. A is contained in U .
Proof.Let f ∈ A and N be a machine computing f .When i / ∈ E, N • M i computes f so any enumeration of its transition table is accepted by the semidecision procedure.As E is not computable, there must exist i ∈ E such that an enumeration of the table of N • M i is also accepted.Let n 0 be such that i is enumerated in E at stage n 0 .N (n) is defined for every n < n 0 and outputs f (n), so the cylinder enumerated in U is [f n0 ].Claim 6.Conversely, every computable function in U belongs to A.
Let g ∈ [v 0 , . . ., v n0−1 ] and M g be a machine computing g with initial state q 1 , all the other states being fresh.Taking the union of the transition tables of N •M i and M g , with the initial state of M i as initial state, one gets a machine M g computing g.The enumeration of the table of N • M i , accepted by the semidecision procedure, can be extended to an enumeration of the table of M g , which is then also accepted (the semidecision procedure halts before being able to distinguish between N • M i and M g ).As a result, g ∈ A.
The proof is complete: given f by an oracle, evaluate it successively on all inputs and look for a cylinder of U containing f .

A difference between a black-box and an oracle
We now exhibit a difference between having a program in a black-box and an oracle.
Instead of deciding or semi-deciding properties, a usual task it to compute a function.In [6] it is proved that Theorem 3.2 ([6]).Let F : X c → Y where X, Y are effective topological spaces and X c is the set of computable elements of X.The following statements are equivalent: There is a Turing machine that computes F (x) given any index of x as input, There is a Turing machine that computes F (x) given any name for x and any k ≥ K(x) as input.We do not insist on the notion of effective topological space, which is essentially a topological space with a countable basis.The classes of partial computable functions or total computable functions are examples of effective topological spaces.A name for an element x is an infinite binary string encoding x in some canonical way, which we do not describe here (the interested reader may consult [13]).
The assumption about effective topological spaces is essential as there is a non-effective topological space Y for which the result fails, which is the class O(N N ) of open subsets of N N (which is not countably-based for the appropriate topology).Here we take for X the class P of partial computable functions.

Theorem 3.3 ([6]
).There is a functional F : P → O(N N ) such that: There is a Turing machine that computes F (ϕ) given any index of ϕ as input, There is no Turing machine that computes F (ϕ) given any name for ϕ and any k ≥ K(ϕ) as input.
Computing an element of O(N N ), i.e. and open set U ⊆ N N , consists in enumerating a list of finite words v i ∈ N * such that U is the corresponding union of cylinders i [v i ].A name for a partial function ϕ is an infinite binary sequence such that ϕ(m) = n if and only if the block 01 n,m 0 appears in the sequence ( ., . is a computable bijection between N 2 and N).
Contrasting with Theorem 3.3 we now show that Theorem 3.4.Let F : P → O(N N ).The following statements are equivalent: There is a Turing machine that computes F (ϕ) given any index of ϕ as input, There is a Turing machine that computes F (ϕ) given an access to a black-box containing a program computing ϕ, and any upper bound onthe size of the program.
The difference with the previous theorem is that: Contrary to an oracle producing a name, a black-box contains an actual program, with its particular halting times, For a particular program p computing a function ϕ, an upper bound on the size of p is always an upper bound on K(ϕ) (the size of the shortest program computing ϕ), but not the converse.In particular the theorem fails if an upper bound on K(ϕ) rather than the size of |p| is provided.
Proof idea.The argument is essentially the same as in the proof of Proposition 2.5.The idea is that the observation of the black-box can be seen as a total computable function that, given an input and a time, tells whether the program on that input halts in that time.Assume that F is computable from indices.Let ϕ be given by a black-box and k an upper bound on the size of the program in the black-box.
At each stage we will have a finite list L of programs, such that the program in the blackbox belongs to this list.At the beginning, L is the set of programs whose size is bounded by k.We enumerate the intersection of the open sets F (ϕ i ) for all i ∈ L. From time to time we may remove an element of L that we know is not the program in the black-box.Each time we change L, we restart the enumeration of the intersection of the open sets F (ϕ i ) for all i in the new list L (a larger open set).Eventually the list L will contain only programs computing the actual function ϕ, so we will enumerate the right open set.
We now explain how we progressively remove programs from L. For each program (in the list or in the black-box), each input n and each number t, we can decide whether the program halts in t steps on input n.If for some n and t a program is inconsistent with the black-box (one halts in t steps on input n but not the other), then the program can be rejected.If for some n the program and the black-box both halt on n giving different outputs, we can also reject the program.
Observe that we do not really need to have a precise measure of the halting time of the black-box: if we know that the actual halting time t of a program and the measured halting time t are related by |t − t| ≤ 10, or t/2 ≤ t ≤ 2t for instance, then we only rejects programs that do not respect this gap w.r.t. the black-box.

Two remarks on The Intensional Content of Rice's Theorem
In this paper we have investigated the properties of functions that are semidecidable, when the function is presented as a program computing it.Such a property can be alternatively seen as a c.e. set of programs that is extensional, in the sense that two equivalent programs -two programs computing the same function -are both in the set or both outside the set.
Asperti [1] investigates the case when extensionality is understood in a weaker sense, i.e. for a stronger notion of equivalence: two programs are equivalent if they compute the same function and have similar complexities (running time, or space, more generally any measure of complexity in Blum's sense).Such classes of programs are called Complexity Cliques.
It is proved in [1] that under certain assumptions on the measure of complexity (which should "behave well" w.r.t. the s-m-n function, composition and parallel computation), Theorem 4.1 (Asperti [1]).No Complexity Clique of total functions and containing programs with non constant complexity can be c.e.
It is asked in [1] whether the assumption about non-constant complexity is needed.
We make the simple observation that it is indeed necessary, because the set of Turing machines with constant time complexity is a c.e. Complexity Clique.Indeed, given c ∈ N, it is decidable whether a given Turing machine always halts in c steps, because one only has to evaluate it on inputs of size at most c + 1, during c steps.Hence it is semidecidable whether a Turing machine has constant time complexity, by trying every possible c.
We also observe that the assumptions about the measure of complexity cannot be dropped either, as the class of one-tape Turing machines that run in linear time is a c.e. Complexity Clique.Indeed, it was recently proved by Gajser [5] that for each c ∈ N, whether a one-tape Turing machine halts in time cn on inputs of size n is decidable (his result is more general as it applies to a larger class of time bounds in o(n log n)).It gives an indirect proof that one-tape Turing machines and their running time do not satisfy the assumptions of [1].

Theorem 2 . 3 .
Let C be a subrecursive class and A ⊆ C .The following conditions are equivalent:

Lemma 2 . 7 .
Theorem, there is e such that ϕ e (a, b) = min{m : h(m) ≥ m 0 (a, b, e)}.Let m(a, b) = ϕ e (a, b).Applying the algorithm on inputs a, b, m(a, b), p where p is the number of values of j ≤ b + 1 such that ϕ j t(j,b) is defined (p is the "right guess") gives a function f ∈ [ϕ a m(a,b) ] \ B b such that K(f ) ≤ m 0 (a, b, e) ≤ h(m(a, b)).We can make sure that m(a, b) > b (in the proof above, take instead ϕ e (a, b) = min{m > b : h(m) ≥ m 0 (a, b, e)}).Let a, b ∈ N and m = m(a, b).

Proof.
Define the computable function b(a) = min{b ≥ |v| : h(b) ≥ a}.We now define a and will take b := b(a).Let g ∈ [v] ∩ A h .By the Recursion theorem, there is a such that For i = b(a), ϕ a (i) = g(i), For i = b(a), ϕ a (i) differs from each ϕ j (i) such that j ≤ b(a) and ϕ j (i) halts in at most m(a, b(a)) steps.Let then b = b(a).
Indeed for each j ≤ b: If ϕ j (b) halts in at most m steps then ϕ a (b) = ϕ j (b) so [ϕ a m ] is disjoint from [ϕ j t(j,b) ] as both m and t(j, b) are larger than b.If ϕ j (b) does not halt in at most m steps then t(j, b) is either undefined or larger than m, so ϕ a m does not contain [ϕ j t(j,b) ].Finally, [ϕ a m(a,b) ] ⊆ [v] as m(a, b) > b ≥ |v| and ϕ a |v| = g |v| = v.
and only if i is enumerated in E by stage n, and N • M i computes the same function as N if i / ∈ E. Proof.Given i, taking the union of the transition tables of N and M i , with the initial state of M i as initial state, one gets a Turing machine N • M i which first behaves as M i , and then if i / ∈ E behaves as N .