Chaitin’s halting probability and the compression of strings using oracles

If a computer is given access to an oracle—the characteristic function of a set whose membership relation may or may not be algorithmically calculable—this may dramatically affect its ability to compress information and to determine structure in strings, which might otherwise appear random. This leads to the basic question, ‘given an oracle A , how many oracles can compress information at most as well as A ?’ This question can be formalized using Kolmogorov complexity. We say that B ≤ LK A if there exists a constant c such that K A ( s ) < K B ( s ) + c for all strings s , where K X denotes the preﬁx-free Kolmogorov complexity relative to oracle X . The formal counterpart to the previous question now is, ‘what is the cardinality of the set of ≤ LK -predecessors of A ?’ We completely determine the number of oracles that compress at most as well as any given oracle A , by answering a question of Miller ( Notre Dame J. Formal Logic , 2010, 50 , 381–391), which also appears in Nies ( Computability and randomness . Oxford, UK: Oxford University Press, 2009. Problem 8.1.13); the class of ≤ LK -predecessors of a set A is countable if and only if Chaitin’s halting probability U is Martin-Löf random relative to A .


Introduction
Kolmogorov complexity is a fundamental notion, which has found applications in topics as diverse as combinatorics, language recognition, information distance, thermodynamics and chaos theory. The basic idea behind this approach to quantifying the degree of randomness of a finite binary string is that a string is simple or non-random if it has a short description relative to its length. Kolmogorov (1965) formalized this idea using the theory of computation. In this context, Turing machines play the role of our idealized computing devices, and we assume that there are Turing machines capable of simulating any calculational process that proceeds in a precisely defined and algorithmic manner. Programs can be identified with binary strings. A string t is said to be a description of a string s with respect to a Turing machine M if this machine halts when given program t and outputs s. Then the complexity of s with respect to M (denoted by K M (s)) is the length of its shortest description with respect to M .
When we come to consider randomness for infinite strings, it becomes important to consider machines whose domain satisfies a certain condition; the machine M is called prefix-free if it has prefix-free domain (which means that no program for which the machine halts and gives output is an initial segment of another). It can be shown that there exists an optimal prefix-free machine U , i.e. a machine that gives optimal complexity for all strings, up to a certain constant number of bits. This means that for each prefix-free machine M there exists a constant c such that K U (s) < K M (s) + c for all finite strings s. Hence, the choice of the underlying optimal machine does not change the complexity distribution significantly and the theory of prefix-free complexity can be developed without loss of generality, based on a fixed underlying optimal prefix-free machine U .
In order to define randomness for infinite sequences, we consider the complexity of all finite initial segments. A finite string s is said to be c-incompressible if K (s) ≥ |s| − c, where K = K U . Chaitin and Levin defined an infinite binary sequence X to be random if there exists some constant c such that all of its initial segments are c-incompressible. 1 This definition of randomness for infinite sequences is then independent of the choice of underlying optimal prefix-free machine, and coincides with other definitions of randomness given in terms of computable betting strategies and also the definition given by Martin-Löf (1966) (a result of Schnorr, see Chaitin (1975)). Strings that are random in this sense are called Martin-Löf random. The coincidence of the randomness notions resulting from these different approaches may be seen as evidence of a robust and natural theory.
If we allow the underlying optimal prefix-free machine access to an oracle A, the resulting complexity K A will often be reduced. Thus, the use of external information often allows for better compression of strings and can be used in order to determine the structure in sequences that would otherwise appear random. The following basic question then arises: Informal question. Given an oracle A, how many oracles can compress strings at most as well as A?
Formally, an oracle X compresses strings at most as well as A if there exists some constant c such that K A (s) ≤ K X (s) + c for all strings s. This relation was introduced by Nies (2005) and is denoted X ≤ LK A. A variant of the LRreducibility called the vL-reducibility was also introduced and studied by Miller & Yu (2008). The formal counterpart to the informal question above now becomes: Given an oracle A, what is the cardinality of {X |X ≤ LK A}? (1.1) It is also a natural question as to whether the ability of an oracle to compress random strings is essentially the same as its ability to compress strings in general. In the same paper that he introduced the ≤ LK relation, Nies also discussed a simple variation; X ≤ LR A if all sets which are Martin-Löf random relative to A are also Martin-Löf random relative to X . In Kjos-Hanssen et al. (in press) it was shown that ≤ LR is identical to ≤ LK , and so our solution to question 1.1 also gives the solution to the corresponding question for the ≤ LR relation.
A short history of the literature surrounding question 1.1 can be found in Barmpalias (2010). The special case when A = ∅ was question 4.4 in Ambos-Spies & Kučera (2000) (stated in terms of ≤ LR ). The main motivation for asking this question at the time was the then recent discovery that there are non-computable oracles X such that K (s) ≤ K X (s) + c for a constant c and all strings s. Such sets X (identifying sets, their characteristic functions and infinite binary strings) are of no use in the task of compressing information and are known as low for K (see Nies 2009, §5.1). Nies (2005) answered this question by showing that if A is computable then the class of question (1.1) is a subset of the class of D 0 2 sets, and hence is countable (a set is D 0 2 iff it is computable in Turing's halting problem-for an introduction to the effective hierarchies, we refer the reader to the excellent book of Hinman (1978)). On the other hand, in Barmpalias et al. (2008) it was shown that this class is uncountable if A is the halting problem. Miller (2010) used a variation of the notion of low for K sets to exhibit a large class of oracles A for which the class of question (1.1) is countable. He called an oracle A weakly low for K if K (s) ≤ K A (s) + c for a constant c and infinitely many strings s, and then showed that if A is weakly low for K then the class of question (1.1) is countable. He also gave the following characterization of the class of weakly low for K sets in terms of the halting probability U = U (s)↓ 2 −|s| . A set A is weakly low for K if and only if U is Martin-Löf random relative to A. The sets A with the latter property are known as low for U. These results prompted the following question. Miller (2010): If A is not low for U, is the class of question (1.1) uncountable?

Question in
(1.2) In this paper, we give an affirmative answer, thus providing a characterization of the sets with uncountably many ≤ LK -predecessors-a set has uncountably many (and so continuum many) predecessors iff it is not low for U.
Theorem 1.1. Let A ⊆ N. Then the following are equivalent.
(b) There are uncountably many X ⊆ N for which there exists c ∈ N such that K A (n) ≤ K X (n) + c for all n ∈ N.
Hence a set is weakly low for K iff the set of its ≤ LK -predecessors is countable.
Notice that the first clause of theorem 1.1 (under a standard identification of strings with numbers) means that A is not weakly low for K (or equivalently, A is not low for U). This theorem unifies a number of older results. For example, in Barmpalias (2010), the first author showed the following.
If A is D 0 2 and not low for K then the class of question (1.1) is uncountable. Moreover it has a P 0 1 perfect subclass. (

1.3)
A class is perfect if it does not contain any isolated points according to the Cantor topology. Since every D 0 2 weakly low for K set is already low for K , (see Nies 2009, exercise 8.1.11) the first part of result (1.3) can be seen as a special case of Theorem 1.1. We note, however, that the latter (or its proof) does not imply the second clause of result (1.3). In retrospect, result (1.3) from Barmpalias (2010) can be seen as an 'effectivization' of theorem 1.1, in the same way that the construction of a maximal set is an 'effectivization' of the construction of a cohesive set.
The advantage of the effective nature of result (1.3) (the fact that we obtain an effectively closed uncountable set) is that it lends itself to the application of basis theorems for P 0 1 classes. For example, the low for U basis theorem (from Reimann & Slaman (submitted) and independently (Downey et al. 2005)) says that every non-empty P 0 1 class contains a low for U path. As was demonstrated in Baartse & Barmpalias (submitted), the proof of result (1.3) can be augmented so as to establish the following.
If A is D 0 2 and not low for K then the class of question (1.1) contains a perfect P 0 1 class without low for K paths. (1.4) Another result from Baartse & Barmpalias (submitted) is the following generalization of the low for U basis theorem.
Every nonempty P 0 1 class contains a non-empty P 0 1 [∅ ] subclass that consists entirely of low for U sets. (1.5) This implies that that every non-empty P 0 1 class without any low for K members contains uncountably many low for U paths. Indeed, in that case, the P 0 1 [∅ ] class that is given by result (1.5) cannot have isolated paths since these would be D 0 2 and so low for K (given that they are also low for U). We can now use these observations to deduce the following fact about the LK -degrees, the degree structure that is induced by the pre-order ≤ LK . Notice that A ≡ LK B (denoting A ≤ LK B and B ≤ LK A) informally means that A and B have the same strength with respect to compressing strings. An LK -degree is D 0 2 if it contains a D 0 2 set. Corollary 1.2. Every D 0 2 non-zero LK -degree bounds uncountably many LKdegrees with countably many predecessors.
The proof is a straightforward combination of results (1.4) and (1.5) and the result from Miller (2010) that if A is low for U then the class {X |∃c ∀s K A (s) ≤ K X (s) + c} is countable.
Given that there have been a number of previous attempts by different people to answer question 1.2, it seems appropriate that we outline the ideas behind the proof of theorem 1.1, especially the new ingredient that made it possible. We do this in §2, as well as providing some preliminaries and notation for the proof that is given in §3.

About the proof of theorem 1.1 (a) Preliminaries
Let U be the optimal prefix-free oracle machine that underlies the prefix-free complexity K X relative to oracles X . Hence K X = K X U for all sets X . This machine is optimal in the sense that given any other prefix-free oracle machine M , there is a constant c such that K X (s) ≤ K X M (s) + c for all strings s and oracles X . We let ⊆, ⊂ denote the prefix or the subset relation (with equality or not) depending on the context. Also, 2 u denotes the set of all infinite binary sequences (which we identify with subsets of N) and 2 <u denotes the set of all finite binary sequences. The oracle machine U can be seen as a computably enumerable (c.e.) set of triples t, r, s , which indicate that U with t written on the oracle tape, and with input program r, halts and produces s. We also write U t (r) = s in order to denote that this relation holds. The set U induces a partial map from 2 u × 2 <u to 2 <u . If X is a set, we let U X = { r, s |∃t ⊂ X , t, r, s ∈ U } and for a string h we let U h = { r, s |∃t ⊆ h, t, r, s ∈ U }. The fact that U X is prefix-free for all X can be expressed by the following condition; If t i , r i , s i ∈ U for i = 0, 1 and t 0 ⊆ t 1 then either r 0 |r 1 , or else r 0 = r 1 and s 0 = s 1 , (2.1) where r 0 |r 1 denotes the incomparability of the two strings with respect to the prefix relation.
It is easy to see that, given U as a c.e. set of triples, we can effectively produce a U and a computable enumeration of U , which satisfies the property that any triple t, r, s appearing in U at stage s has |t| = s, and which induces the same partial map from 2 u × 2 <u to 2 <u . Therefore, without loss of generality, we can assume that in what follows that U is computably enumerated so as to satisfy this latter condition. In this way, we ensure that for each string h the set U h is finite, and we ensure that the map h → U h is computable.
The weight of a prefix-free set S of strings, denoted wgt(S ), is defined to be the sum s∈S 2 −|s| . The weight of a prefix-free machine M X is defined to be the weight of its domain and is denoted wgt(M X ). Without loss of generality, we assume that, for all sets X , wgt(U X ) < 2 −4 and that all strings in the domain of U X begin with 1.
Prefix-free machines are most often built in terms of request sets. A request set L is a set of tuples r, where r is a string and is a positive integer. A 'request' r, represents the intention of describing r with a string of length . We define the weight of the request r, to be 2 − . We say that L is a bounded request set if the sum of the weights of the requests in L is less than 1. This sum is the weight of the request set L and is denoted by wgt(L). The Kraft-Chaitin theorem (see Downey & Hirschfeldt 2010, §2.6) says that for every bounded request set L which is c.e., there exists a prefix-free machine M such that for each r, ∈ L there exists a string t of length such that M (t) = r. The same holds when L is c.e. relative to an oracle X , giving a machine M X . In §3, we freely use this method of construction without explicit reference to the Kraft-Chaitin theorem.
A real number 0 ≤ r < 1 is called c.e. if it is the limit of a non-decreasing computable sequence of rational numbers. For each set X , we define U X := wgt(U X ). Notice that this definition is compatible with the definition of the halting probability U that was discussed above since U = U ∅ . Similarly, we let U h := wgt(U h ) for any string h. The map X → U X is called the U operator and plays a crucial role in §3. By the conventions, we adopted earlier concerning U and its computable enumeration, we have that the map h → wgt(U h ) is computable. Our assumptions about U X also mean that U X < 2 −4 for all oracles X . Real numbers a in the unit interval (like various images of the U-operator) will occasionally be identified with their binary expansions. For example a t denotes the finite sequence consisting of the first t bits of the binary expansion of the real number a (where a real number has two expansions we take the finite one).
Finally, a tree T is a partial map s → T s from strings to strings which preserves compatibility and incompatibility relations between strings, and which has downward closed domain. For any s, the image T s is called a node of the tree. The level of a node T s is |s|. An infinite binary sequence is a path through a tree if infinitely many of its initial segments are nodes of the tree. The set of infinite paths through a tree T is denoted by [T ]. A tree that is a total function may also be called perfect.

(b) Informal ideas behind the proof
In Miller (2010), it was shown that a set is weakly low for K if and only if it is low for U, and that weakly low for K sets have only countably many ≤ LK -predecessors. Therefore, it suffices to show that if a set A is not low for U then it has uncountably many ≤ LK -predecessors. The first construction of an uncountable lower ≤ LK -cone was presented in Barmpalias et al. (2008) Barmpalias (2010) used new ideas in order to implement such a construction below any D 0 2 set that is not low for K . This proof relied entirely, however, on computable approximations. The argument that pointed to the possibility of implementing (a version of) the construction from Barmpalias et al. (2008) below an arbitrary set, which is not low for U, was the proof in Miller (2010) that the class of low for U sets coincides with the class of weakly low for K sets. In this argument, Miller showed how to use short descriptions of U in order to improve the overall compression of programs by any given constant. This is why question (1.2) was asked, sometimes in the form of a conjecture.
Given an oracle A, which is not low for U, the basic plan is to use an A-computable construction to build a prefix-free machine M A and an approximation to a perfect tree T such that K A M (s) ≤ K X (s) for all strings s and all X ∈ [T ]. Since any perfect tree has continuum many paths, this certainly suffices to give the result. The basic obstacle is also clear-the machine M A has to simulate all machines U X for X ∈ [T ], but we must keep the weight of the domain of M A bounded. In order to achieve this, we wish to ensure that where M A has to simulate the descriptions given by a large number of strings in T (corresponding to a high level in T ), the weight of these descriptions is relatively small. Why should we be able to achieve such a goal? For each m and each string r, there exists s ⊃ r such that wgt(U t ) − wgt(U s ) < 2 −m for all t ⊇ s (see Barmpalias et al. 2008, §4). If we were armed with an oracle for ∅ then we could simply find the string s when required and the construction of T would be relatively simple. Now we do not have an oracle for ∅ but we still wish to use the fact that A is not low for U in order to try to identify strings r such that: sup{wgt(U t ) − wgt(U r )|r ⊆ t} is appropriately small. (2.2) How can we make use of the fact that A is not low for U? If A can compress initial segments of U, then in fact it can do the same for the initial segments of any c.e. real. Indeed, by Solovay (1975) (see Downey & Hirschfeldt 2010, § §8.1, 8.2) if B is a c.e. real then K (B n ) ≤ K (U n ) + c for some constant c and all numbers n. So if we approximate X (which is a potential path through T ) in such a way that U X is a c.e. real, then A will be able to compress initial segments of U X . We shall see in a moment how this is useful to us in constructing T . Here, it is important to note that the apparent obstacle to such an approach is that we cannot allow the approximation to X to make any use of the oracle A. If it were to make use of this oracle then we would have no guarantee that U X is a c.e. real, and we would need A to be able to provide short descriptions of U A rather than U, which clearly is not possible. Thus the key new idea in the argument of §3 is to incorporate into the A-computable construction auxiliary procedures which proceed in a computable fashion and do not make any use of the oracle A.
In order to help us define the paths through T we wish to computably approximate sets X with the property that: First of all, let us consider a simplified way of approximating sets X of this kind. Then, we shall have to modify this method slightly in order to ensure that our approximation satisfies some further conditions. The following definition implicitly uses the fact that, for any X , U X is not rational.
Definition 2.1. Given a finite or infinite sequence X , the U-sequence of X is the sequence (n i ), where n i is the least number such that the first i bits (in the binary expansion) of U X are the same as the first i bits of U X n i .
This basic fact will be used many times without explicit mention in what follows.
Now suppose that we wish to approximate X extending t. At stages s ≤ |t| let X s = t s . At stage s + 1 > |t|, suppose that we have already define X s which is a string of length s, and let (n i [s]) be the U-sequence of X s . Check to see if there is some i < s and a string t ⊇ X s n i [s] of length ≤ s + 1 extending t such that U t − U X s n i [s] ≥ 2 −i . If so, then pick the least such i, and for this choice the least such t . Define X s+1 to be the concatenation of t with s + 1 − |t | zeros. Otherwise, let X s+1 = X s * 0.
Since we shall subsequently modify the details of this approximation, we will not yet verify the details precisely. It should be clear, however, that the approximation to X given by this construction converges, that U X is a c.e. real, and that if we let (n i ) be the U-sequence of X then each n i [s] converges to a value n i as s → ∞. Moreover, for all i ∈ N and all B ⊇ X n i , U B − U X n i ≤ 2 −i .
So now suppose that at some point in the process of approximating T , we have defined T s for all s ⊂ s. Imagine that we wish to define T s to be some initial segment of a set X , which is approximated according to a construction like the one above. We have to decide how long this initial segment should be, i.e. where we should aim to start putting further branching in T . Since A is not low for U, for any b we can find r and t such that U A (r) = U X t and |r| ≤ t − b. So, as we computably approximate X , we also use the oracle for A to try to search for a string r of this kind. When we find r that compresses the initial segment of U X s of length t, we can temporarily define T s to be X s n t [s] . If U A (r) is not an initial segment of U X then we will eventually realize this, because U X is a c.e. real. In that case, we can change our mind about T s and then there is no harm done-r simply corresponded to an incorrect guess as regards U X . If on the other hand, U A (r) is an initial segment of U X , then X s n t [s] is an initial segment of X , n t [s] has reached limit n t and for all B ⊇ X s n t [s] , U B − U X s n t [s] ≤ 2 −t . Roughly speaking then, since |r| ≤ t − b, there is sufficient room above r to simulate the machines corresponding to up to b-many paths extending X s n t [s] . So it is reasonable to put a branching into T here.
While this provides the basic idea, what we have said so far is not quite correct. In the situation above, when U A (r) is an initial segment of U X , it will be the case that X s n t [s] is an initial segment of X , n t [s] has reached limit n t and that for all B ⊇ X s n t [s] , U B − U X s n t [s] ≤ 2 −t , while the measure of all strings extending r is at least 2 b−t . The slight complication is that just as we had to approximate T s , all the values T s for s ⊃ s will also have to be approximated. As we approximate T we do not know which nodes we shall subsequently have to change our mind about, and thus, in practice, we have to simulate the machines corresponding to all strings that appear to be in T at any stage (not just those corresponding to the nodes in the final version of T ). We, therefore, need to approximate X in such a way that we successfully coordinate our need to satisfy condition (2.3), while at the same time limiting the cost incurred by our changing approximation to X and the corresponding T s . We now formally describe the computable subroutine that defines the appropriate approximation.

(c) The computable subroutine of the construction
Given inputs s ∈ 2 <u and e ∈ u, the following lemma provides an algorithm that produces a computable approximation (X s ) converging to an infinite extension X of s. For each s, X s is a string of length s. When X s+1 extends X s , we define c K (s + 1) = 0, and otherwise we define c K (s + 1) = U X s − U X s n , where n is the least such that X s (n) ↓ = X s+1 (n) ↓. We define the 'low for K ' cost that is associated with (X s ) to be: and we ensure that this cost is at most 2 −e . According to the standard 'cost function method' of constructing low for K sets (e.g. see Nies 2009, proposition 5.3.34), the set X is low for K . In lemma 2.2, we establish some additional details concerning (X s ), which play a crucial role in the proof of theorem 1.1.

Lemma 2.2 (Computable subroutine).
Let a string s and a number e > 0 be given. Then we can find a computable sequence (X s ) of strings with the following properties, where (n t [s]) denotes the U-sequence of X s .
(1) |X s | = s for each s ∈ N and (X s ) tends to an infinite extension X of s with U sequence denoted by (n i ).
(2) The low for K cost of (X s ) as this is defined in result (2.4) is < 2 −e .
(3) (U X s ) is a non-decreasing sequence tending to U X .
(4) For each i ∈ N, the sequence (n i [s]) s∈N tends to n i as s → ∞.
(5) U r − U X n t < 2 e−t for all t and all r ⊃ X n t with r ⊃ s. Proof. Given a string s and a number e we show how to define the computable function h(s, e)[s] := X s for all s ∈ N. The basic idea is as follows. At stage s + 1, we make sure that if k is the least number such that X s (k) ↓ = X s+1 (k) ↓ (should there exist any such) and if t is the greatest number such that n t [s] ≤ k, then U X s+1 − U X s k ≥ 2 e−t . Hence, we only allow this change to our approximation of X at stage s + 1 if it adds at least 2 e−t − 2 −t to the current approximation to U X . Thus, every time we pay cost c K (s + 1) = e, the monotone approximation to U X increases by at least (2 e − 1) · e. Since U X < 1/2 4 and e > 0, this guarantees that the overall cost corresponding to (X s ) is less than 2 −e .
The precise instructions are as follows. At stages s ≤ |s|, let X s = s s . At stage s + 1 > |s|, let n i [s] be the U-sequence of X s . Check to see whether there exists some i < s and a string t ⊇ X s n i [s] of length ≤ s + 1 with s ⊂ t such that U t − U X s n i [s] ≥ 2 e−i . If so, pick the least such i, and for this choice the least such t. Define X s+1 to be the concatenation of t with s + 1 − |t| zeros. If not, then let X s+1 = X s * 0.
Clearly, the function h(s, e)[s] is computable. First we show the second property, i.e. that the low for K cost of (X s ) (as this is defined in condition (2.4)) is less than 2 −e . Suppose that X s (k) = X s+1 (k) and X s k = X s+1 k for some s, k ∈ N. Then at stage s + 1, the construction acted on the basis of some i, t (see the description of stage s + 1 of the construction) such that k > n i [s]. Hence, U X s+1 − U X s n i [s] ≥ 2 e−i , which means that the U-image of X s+1 is larger than that of X s by at least 2 −i (2 e − 1). On the other hand, the cost c K (s + 1) that occurred at stage s + 1 is < 2 −i . Hence every time some cost e is registered, an increase of at least e(2 e − 1) occurs in the sequence (U X s ) s∈N . According to condition (2.4), it follows that the low for K cost of (X s ) is less than 2 −e .
For property (3), notice that (since e > 0) the inequality U t − U X s n i [s] ≥ 2 e−i implies that U t > U X s . Hence by the construction, U X s ≤ U X s+1 for all s ∈ N. Property (6) follows from property (3). Hence for each i ∈ N, the sequence U X s n i [s] can only change finitely many times and n i [s] reaches a limit as s → ∞. Since the image of U under any oracle is an irrational number, it follows that the final positions of the n i [s] are unbounded, and X s reaches a limit X . Moreover since (n i [s]) is the U-sequence of X s , the limit of n i [s] as s → ∞ is n i . This argument demonstrates properties (1) and (4).
For property (5), let s be such that n t [r] = n t and X r n t [r] = X n t for all r ≥ s. Then U r − U X n t < 2 e−t for all r ⊃ X n t with r ⊃ s, since otherwise n t [r + 1] = n t [r] for the first stage r + 1 > s at which we find r violating this condition.
With the function h now defined according to the lemma, there are just two more considerations to be had before we can specify the entire construction precisely. Firstly, when we defined T s in the discussion above, there was a string r associated with T s , which compressed an initial segment of U T s , and the measure of the set of strings extending r was seen to give a certain amount of room for simulating machines with oracle input extending T s . There is nothing to stop there being multiple strings s, however, for which r is the string associated with T s in this way. This is easily dealt with using some simple accounting. Corresponding to each s, we shall have values a s and b s , and r is chosen so as to compress by a margin, which depends upon these values in such a way that these sums work out as they should.
It is also worth clarifying the architecture of the construction, which allows us to run computable subroutines, while the procedure as a whole makes use of the oracle A in order to build our approximation to the required perfect tree. Certainly one may have a computable routine running in parallel with an oracle computation. If the oracle computation makes use of values outputted by the computable routine, this in no way affects the computability of the routine. Further, if the oracle computation in fact decides which computable routines should be run in parallel, and which values produced by those computable routines it wishes to use in its oracle computation, this in no way affects the computability of the routines that it chooses to run. Thus, we define a construction that uses an oracle A, and which refers to values produced by computable subroutines, which themselves do not make any use of the oracle.

Proof of theorem 1.1 (a) The machine M
In §3c, the machine M A is defined in terms of a uniformly A-c.e. family of bounded request sets L r , indexed by strings in the domain of U A (and the extra 1-bit string 0, see below). This family gives a uniformly A-computable sequence of machines M A r such that for each request t, in L r there exists a string h of length such that M A r (h) = t. The main machine M A is defined as follows.
Since each machine M A r is prefix-free (and all strings in the domain of U A are incomparable with the 1-bit string 0, according to the conventions of §3a) it follows from definition (3.1) that M A is prefix-free. where s ranges over all strings and ∅ denotes the empty sequence. The parameter b s will be used in the construction to help make sure that there is a room for the descriptions that are allocated to T s , and will be updated upon an 'injury' of this node. A second parameter a s will indicate our belief as regards an upper bound to sup r (U r − U T s ), where r runs over all extensions of T s .
We order the strings first by length and then lexicographically. Define T ∅ [s] = ∅ for all stages s, where ∅ denotes the empty string. This means that in the approximation T [s] to T , the root of the tree will always be the empty string.
Let s be a non-empty string and let j be its last digit, so that s = h * j for some string h. Also let (n t [s] Following a standard convention, the latter expression is simplified to h(T h * j, a h )[s]. We say that T s requires attention at stage s + 1 if |s| > 0 and one of the following conditions holds.
(a) T s [s] is undefined and there exists a string r of length < s such that and r is the string associated with T s .
So a node requires attention either when it is undefined and is ready to be defined (corresponding to case (a)), or else is defined and should be made undefined (corresponding to case (b)).
As discussed previously, each T s will be associated with a string in the domain of U A . We trivially let T ∅ be permanently associated with the 1-bit string 0. In order to cover this trivial case (and since the string 0 is incomparable with all strings in the domain of U A , see §3a), we use the special set L 0 for the enumeration of requests corresponding to definitions of T 0 and T 1 , and we let a ∅ [0] = 4. Thus, every definition of some T s entails an enumeration of requests into L r , where r is the string associated with T h , and h is the immediate predecessor of s.

(c) Construction
At stage s + 1 let s be the least string such that T s requires attention (or if there exists no such then proceed to the next stage). Let j be the last digit of s so that s = h * j for some string h. If T s [s] is defined, let b t [s + 1] = b t [s] + 1 for all t ⊃ s. Also let T t [s + 1], a t be undefined for all t ⊇ s and disassociate the strings in the domain of U A that were associated with them. Declare that the nodes T t for t ⊃ s are injured.
Otherwise (d) Verification The following lemmas establish the required properties of the construction of §3c. infinite sequence X such that U X is a c.e. real. By the same lemma, each term n i [s] of the U-sequence of X s reaches a limit n i as s → ∞, and since U X is irrational lim i n i = ∞. Since A is not low for U, there exist infinitely many n ∈ N such that K A (U X n ) < n − a h − b s . Choose the least string y such that U A (y) = U X t for some t with n t > |T h * j| and |y| < t − a h − b s . Let s 1 > s 0 be sufficiently large that n t [r] = n t and X r n t = X n t for all r ≥ s 1 and U A (y)[s 1 ] = U X t . Let s 2 > s 1 be a stage such that for any string k less than y and all stages s ≥ s 2 one of the following holds: Such a stage exists by the minimality of y and the fact that U X s is a computable non-decreasing sequence of rational numbers that tends to U X . Now if T s ever became undefined after stage s 2 , it would require attention (by the choice of y and s 2 ). No T r with r less than s would require attention at such a stage, since these nodes have reached their limit values. Therefore, T s would receive attention and would be defined based on y (i.e. defined with associated string y) at some stage s 3 > s 2 . The parameter T s [s 3 ] would be given the value X s 3 n t = X n t (for t = |U A (y)|), a s would be given the value |U A (y)| − a h and these values would never subsequently be redefined. Thus T s , a s and b s reach limit values, as required.
Let T s := lim s T s [s] for each string s. Notice that for each h and stage s the nodes T h * 0 [s] and T h * 1 [s] are extensions of T h and are incomparable with each other (unless one of them is undefined). Hence their final values will have the same properties and the function s → T s is a perfect tree.
According to the definition of h this would cause us to define X s+1 so that t ⊆ X s+1 and n t [s + 1] = n t [s], a contradiction. Lemma 3.3. For each string m the weight of L m is < 1. Hence M is a prefix-free machine.
Proof. Fix a string m. Enumerations into L m occur when a node T s with s = h * j becomes newly defined and T h has the string m currently associated with it. Hence every enumeration into L m during the construction can be allocated to the unique node T h whose immediate successor became defined at the stage where the enumeration occurred. Let L m (T h ) be the set of tuples y, in L m that are assigned to T h in this way. Then wgt(L m ) = h wgt(L m (T h )). By result (3.2) it suffices to show that wgt(L m (T h )) < 2 −b h [0]+3 for all strings h. (3.3) In the special case, where m is the 1-bit string 0, this weight is 0 unless h is the empty string. In the latter case, we have b h [0] = 4 by result (3.2) so it suffices to show that wgt(L 0 (T h )) < 2 −1 . The requests that are enumerated into L 0 (T h ) come from various definitions of the nodes T 0 , T 1 during the construction. Let X s := h(T h * 0, a h )[s] and let X be the limit of this sequence. Notice that T h is the empty sequence and a h [s] = 4 for all stages s, so that X s = h(0, 4)[s]. Clearly, the weight of the requests that are enumerated into L 0 (T h ) and which are caused by the various definitions of T 0 is bounded by 2 · (U X + c), where c is the 'low for K cost' of the approximation (X s ) → X (the factor 2 here comes from the fact that in the last line of the construction we enumerate the request y, |x| − |m| rather than the request y, |x| into L m ). By lemma 2.2, we have c < 2 −4 and by the conventions established in §3a, we have U X < 2 −4 . Hence, the weight of the requests that are enumerated into L 0 (T h ) as we define T 0 is bounded by 2 −2 . Similarly the weight that is caused by the various definitions of T 1 is bounded by 2 −2 . Hence wgt(L 0 (T h )) is bounded by 2 −1 . This concludes the proof of result (3.3) in the special case when m is the 1-bit string 0. Now suppose that m is in the domain of U A and let h be any string. Notice that if h is the empty string then the weight in result (3.3) is 0. So without loss of generality we may assume that h is non-empty, say h = z * z for a string z and some z ∈ {0, 1}. Notice that each time T h is declared injured, the current value of b h increases by 1. Consider a partition of all stages into maximal intervals where T h remains uninjured (in other words, T z remains constantly defined). Let L * m (T h ) denote the requests that are allocated to T h and are enumerated into L m during one of these intervals I . To establish result (3.3) it suffices to show that where b * h denotes the value of b h during the interval I . Notice that during the stages in I the node T h may be redefined many times, but each time it is redefined during this interval, it will be associated with a different string than at all previous stages during the interval (in fact, lexicographically to the right of all previously associated strings, within the interval of stages). This follows from the current definition of T h in the construction via h, and property (6) of h in