Effectivizing Lusin’s Theorem

: Lusin’s Theorem states that, for every Borel-measurable function f on R and every ε > 0, there exists a continuous function g on R which is equal to f except on a set of measure < ε . We give a proof of this result using computability theory, relating it to the near-uniformity of the Turing jump operator, and use this proof to derive several uniform computable versions. Easier results, which we prove by the same methods, include versions of Lusin’s Theorem with Baire category in place of Lebesgue measure and also with Cantor space 2 N in place of R . The distinct processes showing generalized lowness for generic sets and for a set of full measure are seen to explain the differences between versions of Lusin’s Theorem.


Introduction
Lusin's Theorem, first proven by Nikolay Lusin (or Luzin) in 1912, states informally that every measurable function on the real numbers R is "nearly continuous," in terms of the Lebesgue measure µ on R. The standard formal statement is as follows.
Alternative versions allow ±∞ as values of the functions in question.(Some versions only state that f restricts to a continuous function on a set of comeasure < ε, but we will consider the stronger version.)A common method of proof of this result involves Egorov's Theorem, that continuity of a function on a compact set is "nearly" uniform continuity.Indeed, in the standard text Royden [4], Lusin's Theorem is posed as an exercise, following the exposition of Egorov's Theorem.On the other hand, Rudin [5,Theorem 2.24] proves Lusin's Theorem from basic principles (and later poses Egorov's Theorem as an exercise).
The purpose of this article is to show that Lusin's Theorem is a direct consequence of the fact, well known in computability theory, that for almost all sets X of natural numbers, the jump X ′ of X satisfies the property ie the jump, which is essentially the Halting Problem relativized to X , can be computed merely from the Halting Problem ∅ ′ along with X itself.(The join ∅ ′ ⊕ X = {2n : n ∈ ∅ ′ } ∪ {2n + 1 : n ∈ X} is a least upper bound of ∅ ′ and X under ≤ T .)Certain sets X fail to satisfy this property, but those sets form a meager subclass of measure 0 within the Cantor space 2 N .The computability-theoretic reason why Lusin's Theorem needs to use an ε > 0 is that the Turing reduction from X ′ to ∅ ′ ⊕ X is only uniform up to a set of measure ε.In contrast, when we use Baire category theory, comeager-many X ∈ 2 N satisfy X ′ ≤ T ∅ ′ ⊕ X , and here a single Turing reduction succeeds uniformly on the entire class.This accounts for the companion theorem in analysis, which is much easier to prove and requires no ε-fudging: that every Borel function f restricts to a continuous function whose domain is a comeager subset of R.
Our proof of Lusin's Theorem demands more background in computability and descriptive set theory than the standard proofs.The point is not to replace the original proofs, but rather to highlight the connections between Lusin's Theorem and computability theory.When given in full, our proof will require substantial attention to detail, but it can be summarized very neatly as the following sequence of steps.
(1) As shown in Weihrauch [8], the continuous functions g : R → R are precisely those for which there is a Turing functional Γ and an oracle S ⊆ N such that, for all Cauchy sequences X converging fast to any x, Γ S⊕X converges fast to g(x).
(2) Borel-measurable functions f(x) are those which can be described (in computable analysis) by the action of a Turing functional Φ whose oracle is the α-th jump of the input x, for some countable ordinal α that depends on f , along with an oracle set S ⊆ N.That is, if X is a representation (normally by a fast-converging Cauchy sequence) of x, then Φ ((S⊕X) (α) ) computes a Cauchy sequence which converges fast to f(x).The ordinal α gives the level of f in the Borel hierarchy (sometimes denoted by F σ , G δσ , etc; also by Σ α or Π α ).This generalizes the preceding item, where α = 0, (3) For each fixed ordinal α < ω 1 , almost all subsets X ⊆ N have the property that the α-th jump X (α) is Turing-reducible to ∅ (α) ⊕ X .(For α = 1, such an X is said to be generalized low 1 , or GL 1 ; this situation was described above.)More generally, relativizing to a fixed S ⊆ N, almost all X satisfy (S ⊕ X) (α) ≤ T S (α) ⊕ X .Details appear in Stillwell [7].(4) In the preceding item, "almost all" refers to Lebesgue measure on the space of inputs X , and the Turing reducibility, while not uniform, is uniform up to a set of arbitrarily small measure, and moreover is uniform in the bound on that set's measure.That is, there is a Turing functional Ψ such that, for every ε > 0 and every S: We often write Ψ ε for the unary functional Ψ(ε, •).Ψ ε is not uniform in α.
Taken together, these four items suggest a natural approach for proving Lusin's Theorem: if f(x) is given by Φ (S⊕X) (α) as in (2), and (S ⊕ X) (α) is given in turn by Ψ S (α) ⊕X ε , then composing these two should yield a function Γ S (α) ⊕X = Φ Ψ S (α) ⊕X ε which will be continuous by virtue of item (1) and will equal f up to a set of measure < ε by virtue of item (4).Of course, many readers will have spotted potential flaws in this argument already, and it will require a good deal of work to address them.In particular, even for those X on which Ψ ∅ (α) ⊕X fails to output X (α) , Γ must still give a coherent output, ie a fast-converging Cauchy sequence.Moreover, the sequences computed by Γ for two distinct X 0 and X 1 must converge to the same real number whenever X 0 and X 1 both converge to the same input x.Of course, each x is the limit of continuum-many fast-converging Cauchy sequences, many of which may not be handled correctly by Ψ, so this appears to be a serious problem.Finally, Lebesgue measure on Cantor space 2 N is used for the statement that almost all X are GL 1 , whereas we must use Lebesgue measure on R, represented as a quotient of the space of all fast-converging Cauchy sequences, to address Lusin's Theorem.
Nevertheless, we will overcome these difficulties and give a proof of Lusin's Theorem essentially following the outline given above.This will require a reasonable background in computable analysis and also in the computability-theoretic notion of the jump operation on subsets of N and its iteration through the countable ordinals.Two appendices (Sections 10 and 11) are devoted to these two topics, as few readers can be expected to be closely familiar with both of them.For more extensive presentations, we suggest [8] for the computable analysis; Kechris [3] for descriptive set theory such as the preceding characterization of the Borel functions; Soare [6,Chapter III] for the basics of the jump; and Ash and Knight [1, for iterating the jump through the computable ordinals, which generalizes by relativization to all countable ordinals.
When we prove it, Lusin's Theorem will reappear as Theorem 6.2.It is normally stated as above, for the real numbers R, but it also applies to Cantor space 2 N .Additionally, there are analogous theorems (for both R and 2 N ) using Baire category in place of Lebesgue measure.Each of these is simpler to prove than Theorem 6.2, and we will use them as warm-ups, introducing several of the techniques required in the more complex context of Theorem 6.2 itself.Moreover, these results will demonstrate the connection between computability and a standard question about these theorems.The question is, "why does Lusin's Theorem only yield g = f up to a set of positive measure, with different functions g for different positive values of ε, when the Baire-category version gives a single continuous g that equals f everywhere except on a meager set?"This will be seen to be a direct consequence of the nature of computing X ′ from ∅ ′ ⊕ X uniformly.A uniform computation is possible on a comeager set of X -values (with no wrong answers even for the other X , but sometimes with no answer given).Under Lebesgue measure, some guessing is required, and therefore each uniform computation will be wrong on some set of positive measure (although at least it will always provide an answer, albeit occasionally an incorrect one).In some respects this can be seen to reflect the distinction between the modern notions of generic computability and coarse computability, as described for instance in Jockush and Schupp [2].
Notation here is standard and follows Soare [6].In particular, capital Greek letters such as Φ, Γ, and Ψ denote oracle Turing functionals, and Φ 0 , Φ 1 , . . . is a standard computable enumeration of all such functionals.Sometimes Φ e,s is used to denote the version of the functional Φ e that automatically halts after s steps, even if it has no output yet.We write a, b, q, r, u, v and sometimes ε for rational numbers; a, b, r, x, y for real numbers; capitals including A, C, X , and Y for elements of Cantor space 2 N (that is, for subsets of N, often used as oracles for a functional); and f , g for functions mapping 2 N → 2 N or R → R. Some further notation is described in the appendices (Sections 10 and 11).

Acknowledgments
The author was partially supported by Grant #DMS -1362206 from the National Science Foundation, Grant #581896 from the Simons Foundation, and several grants from the PSC-CUNY Research Award Program.This work was initiated at a workshop held at the Schloß Dagstuhl in February 2017, where Vasco Brattka aided its development with useful conversations.It was subsequently improved by several suggestions from an anonymous referee.

Computing Discontinuous Functions
Section 10 gives background in computable analysis, including our reasons for using enumerations of Dedekind cuts to name real numbers, rather than fast-converging Cauchy sequences.Theorem 10.4 shows that it is impossible to compute a discontinuous function f : R → R just from enumerations of Dedekind cuts for the input x ∈ R.However, if we allow ourselves more information about x, then it becomes possible.
there exists a Turing functional Φ such that, for every x ∈ R and every enumeration X = A ⊕ B of the Dedekind cuts of x, the function computes an enumeration of the Dedekind cuts of f(x).
More generally, for an ordinal α < ω 1 and an oracle set S ⊆ N, f is α-jump Scomputable if there exists Φ such that, for every x ∈ R and every enumeration X of the Dedekind cuts of x, computes an enumeration of the Dedekind cuts of f(x); similarly for functions on 2 N .
If α is a countable noncomputable ordinal, then the α-th jump is not well-defined in general.Section 11 explains how we can choose an oracle S complex enough to compute the complete diagram of a presentation A of α (ie, a linear order A isomorphic to (α, ∈) whose domain is N).So it is possible to discuss the situation α ≥ ω CK 1 , although one must fix an S-decidable presentation A of α.Since we defined the A-jump C (A) to have C itself as its 0-th column, a functional Φ with oracle (S ⊕ X) (A)  can recover S from that column of the oracle, use it to compute the presentation A, and thus make sense of the oracle (S ⊕ X) (A) uniformly.
The principal theorem relevant here can be found in Kechris [3].By Lemma 10.3, for functions on R, this theorem holds with x and f(x) represented either by fast-converging Cauchy sequences or by enumerations of Dedekind cuts.Theorem 3.2 For every Borel function f : 2 N → 2 N , there is a Turing functional Φ, an oracle S ⊆ N, and an S-decidable presentation A of some countable ordinal such that, for every X ∈ 2 N , Φ (S⊕X) (A) : N → {0, 1} is the characteristic function of f(X).Similarly, for every Borel function f : R → R, there is a Turing functional Φ, an oracle S ⊆ N, and an S-decidable presentation A of some countable ordinal such that, for every enumeration A ⊕ B of the Dedekind cuts of any x ∈ R, Φ (S⊕X) (A) enumerates the Dedekind cuts of f(x).
Computable analysts have commonly approached jump-computability the opposite way, by taking the limit of a computable function: That is, for each s ∈ N, one computes an approximation to f(x), and the actual value f(x) is the limit of these approximations.As an example, the derivative of a differentiable function h(x) could be given by letting Φ X be the difference quotient s • (h(x + 1/s) − h(x)).The Turing functional Φ is readily defined from the functional and oracle computing h.(The derivative of a computable differentiable function is not in general computable, so this is often the best that can be done.)The connection between this method and ours is given by the Transparency Lemma.Lemma 3.3 (Transparency Lemma (folklore)) A function is jump-computable if and only if it is the limit of a computable function (in the sense immediately above).
So one could attack Lusin's Theorem by iterating the limit operation instead of the jump operation.Our choice to use the jump is dictated mainly because it allows us to apply the known results of Section 11 on near-uniform continuity of the jump, especially Theorem 11.4.

Results on Cantor Space 2 N
Our two main theorems about Borel functions on Cantor space depend heavily on three lemmas, which are the heart of the connection between computability and Lusin's Theorem for 2 N .These lemmas are well-known, but due to their importance, we give the proofs here, at least for the base case α = 1.Understanding them will prepare the reader for the analogous theorems about functions on R, which are conceptually similar but more technical.The three analogous lemmas for R all appear in the appendix (Section 11).Lemma 4.1 Let X ∈ 2 N be generic.Then X ′ ≡ T ∅ ′ ⊕ X ; indeed, there exists a single Turing functional Ψ such that, for every generic (or even 1-generic) X ∈ 2 N , Ψ (∅ ′ ⊕X) computes the characteristic function of X ′ .More generally, for every oracle set S ⊆ N and every S-decidable presentation A of a countable ordinal α, there exists some Ψ such that, for all X ∈ 2 N that are generic relative to S, Ψ (S (A) ⊕X) computes the characteristic function of (S ⊕ X) (α) .Moreover, even for non-generic X ∈ 2 N (and for every e ∈ N), Ψ (S (A) ⊕X) (e) either diverges or computes correctly whether e ∈ (S ⊕ X) (α) .
Proof We describe here the situation with S = ∅ and α = 1.Given the oracle (∅ ′ ⊕ X), the functional Ψ on input e ∈ N asks, for s = 1, 2, . . . in turn: • whether Φ (X↾s)  e,s (e) halts (using no more of the oracle than the first s bits); and also • whether there exists any σ ⊇ X↾ s and any t such that Φ σ e,t (e) halts.If the first answer is ever positive, Ψ concludes that e ∈ X ′ , while if the second answer is ever negative, Ψ concludes that e / ∈ X ′ .Each conclusion is clearly correct (if ever reached), and for a 1-generic X , one of these conclusions must eventually be reached.(Notice also that, even for non-generic X , Ψ (∅ ′ ⊕X) never gives a wrong answer.However, it could simply never give an answer.) For successor α = β + 1, a similar procedure relativized to ∅ (β) succeeds.The proof of the general result uses the uniformity of the above procedure for all β < α.
Our first Lusin-type result follows from Lemma 4.1.This is a standard theorem.Theorem 4.2 Let f : 2 N → 2 N be a Borel function.Then f restricts to a continuous function g whose domain is the (comeager) set G containing all elements of 2 N that are generic relative to S.
Proof Theorem 3.2 yields Φ, S, and A (as described there) such that Φ (S⊕X) (A) computes f(X) for every X ∈ 2 N .Its restriction to G is therefore computed by as witnessed by Lemma 4.1.Since this function is S (A) -computable, it is continuous on its domain, which contains the comeager set G. (For X / ∈ G, either the computation will output the correct value f(X), or there will exist some input n on which the computation never halts.As noted above, the computation will never give an incorrect answer, even for a single n.) Now we turn to Lebesgue measure on 2 N , for which each basic open set U σ = {X ∈ 2 N : σ ⊆ X} has measure 2 −|σ| , with the measure extending to all measurable subsets of 2 N in the usual Lebesgue definition.There is an analogue of Lemma 4.1 for Lebesgue measure, but, perhaps contrary to one's expectations, it is uniform only for sets of arbitrarily small measure, not up to a set of measure zero.The following lemma appears as Theorem 2 of Stillwell [7], but a proof may also be deduced from the (more complicated) Lemma 11.3 and Theorem 11.4 in the appendices, especially in concert with the proof of Lemma 4.4 below.Lemma 4.3 For every oracle set S ⊆ N and every S-decidable presentation A of a countable ordinal α, there exists some Ψ such that, for each fixed rational ε > 0, Ψ (S (A) ⊕X) (ε, •) computes the characteristic function of (S ⊕ X) (A) for all X outside a subset of 2 N of measure < ε.Moreover, the computation Ψ (S (A) ⊕X) (ε, e) halts for every X ∈ 2 N and every (ε, e), although for X within the set of measure < ε it may output a value distinct from the "correct" answer χ (S⊕X) (A) (e).
We will write Ψ ε for the function Ψ(ε, •), with any oracle.For Lebesgue measure, a second fact is also necessary.Lemma 4.4 In Lemma 4.3, the error set described, whose measure is < ε, is the union of an S-computably enumerable sequence of basic open sets, uniformly in both A and ε.
Proof First we explain this proof when α = 1 and with S omitted.Now Ψ ∅ ′ ⊕X ε is attempting to compute X ′ as described in Lemma 4.3.Whenever Ψ ∅ ′ ⊕X ε (e) ↓= 1, it does so because it has seen the computation Φ X e (e) converge already, so e ∈ X ′ and this answer is correct.All errors (if any occur for this X ) occur for values e where Ψ ∅ ′ ⊕X ε (e) ↓= 0.
To enumerate an error set, therefore, once Ψ ε has declared that Ψ ∅ ′ ⊕X ε (e) ↓= 0 for all X extending some particular τ ∈ 2 <N , we watch for any strings ρ ⊇ τ and any t for which Φ ρ e (e) ↓.Any time we find such a ρ, we enumerate the basic open set defined by τ into our error set, knowing that this entire basic open set lies in the error set.Since all errors are errors of this type (guessing that e / ∈ X ′ and later being proven wrong), this list of basic open sets is precisely the error set and thus has measure < ε.
In the general setting, the jump (S ⊕ X) (A) consists of many columns, one for each point k in the presentation A of the ordinal α.If k represents a successor ordinal β + 1 in A, then we do the same procedure as above, waiting for Ψ ε to use its own computation of (S ⊕ X) (β) to declare that e / ∈ (S ⊕ X) (β+1) for all X ⊃ τ and then watching for Φ (S⊕ρ) (β)   e (e) ↓ for each ρ ⊇ τ .Only ε • 2 −k−1 of the measure ε of the error set is allotted to this process, and it certainly enumerates all X for which Ψ ε gave the wrong answer about whether some e lies in (S ⊕ X) (β) but gave correct answers to these questions for all ordinals < β .Now, if in fact Ψ ε gives a wrong answer for some e about whether e ∈ (S ⊕ X) (A) , then there is a least element β of α for which it did so, and for this β , X will belong to a basic open set enumerated into our error set.Theorem 4.5 Let f : 2 N → 2 N be a Borel function, and fix ε > 0. Then there exists a continuous function g : Proof The proof is somewhat analogous to that of Theorem 4.2, using Lemmas 4.3 and 4.4.In order to ensure that g is defined on all of 2 N (which was impossible in Theorem 4.2), we must provide a value for g(X) even for those X such that The danger here is that for these X , the functional Φ running with the incorrect oracle Ψ (S (A) ⊕X) ε (ε, •) may fail to compute a total function, in which case our naive version of g, namely Φ Ψ (S (A) ⊕X) ε will fail to map all of 2 N into 2 N .Therefore it is necessary for us to be able to realize, at some point during the computation above, that Ψ S (A) ⊕X ε fails to compute (S ⊕ X) (A)  correctly.This is exactly the point of Lemma 4.4.
The procedure for Γ begins by starting the naive computation Φ Ψ (S (A) ⊕X) ε .If we ever reach a stage s at which the s-th basic open set (given by a string σ s ∈ 2 <N such that the basic open set is {Y ∈ 2 N : σ ⊂ Y}) in the enumeration above contains X -ie, σ s ⊂ X -then at that stage we simply end the computation on all inputs: the output is where Ψ ε,s indicates that we only run Ψ ε for s steps.If we never reach such a stage s, then Γ continues running each computation Ψ (S (A) ⊕X) ε until it halts, as it must, since in this case, with X not in the error set, this function succeeds in computing f(X).Thus Γ does indeed compute a function g defined on all of 2 N , and thus continuous, differing from f only on the error set.Notice also that the computation of an index for g is uniform in the positive rational ε chosen.Theorems 4.2 and 4.5 are not perfectly analogous.The former yields a single continuous version of f that may be undefined on a small (ie meager) set of inputs X .The latter yields different versions g ε for each ε > 0, each of which is continuous on all of 2 N but may differ from f on a small set (ie of measure < ε).The computability-theoretic difference between working with generic sets and working with Lebesgue measure accounts for the difference in the corresponding lemmas, and thus may be seen as explaining the difference between the theorems.
The technique of enumerating the error set, used in Lemma 4.4, will reappear in Section 6, when we address Lusin's Theorem itself using Lebesgue measure on R.
5 Baire Category on R Our next step is to address the real line R rather than Cantor space 2 N .The difficulty here lies in representing real numbers x ∈ R, since our fundamental objects are elements X ∈ 2 N and each x ∈ R will be represented by many different X ∈ 2 N , each naming a Cauchy sequence in Q that converges fast to x.(In Section 4, this was not an issue: each X ∈ 2 N simply represented itself!)Indeed, the X 's representing a single x will have many distinct Turing degrees.
The first impulse, for addressing this problem, is to switch to Dedekind cuts, since each x ∈ R is represented by a single strict left Dedekind cut (ie, a nonempty subset of Q, downward-closed under <, with no greatest element).Unfortunately, these cannot be used directly as oracles: the analogue of Lemma 10.3 for this system of representation of real numbers is false.Lemma 10.3 is our compromise, converting fast-converging Cauchy sequences into enumerations of strict left and right Dedekind cuts (and back) effectively.This is not a perfect solution, since for a given x the strict left and right cuts L x and R x each have many distinct enumerations, of many Turing degrees.However, as we now describe, it enables us to use enumerations of these cuts to run oracle Turing computations in an effective way, so that the output depends only on L x and R x (and thus only on x itself), not on the choice of enumerations of L x and R x .Definition 10.1 describes the "canonical" enumeration of each x, which is crucial for the proof of the next theorem.Our use of Dedekind cuts stems from our lack of any similar notion of a canonical Cauchy sequence converging fast to x.
The generic real numbers form a comeager subset G of R, where by definition x ∈ R is generic just if the cut L x is generic among all downward-closed sets of rational numbers.Clearly, genericity among such sets rules out having a greatest element, being empty, or being co-empty, so these sets are all strict left cuts of irrational numbers x.Moreover, no definable left cut x can be generic in this sense.This set G will be the comeager set we use to prove the Baire-category version of Lusin's Theorem.Proof Once again, Theorem 3.2 yields Φ, S, and A such that, for every x ∈ R and every enumeration A ⊕ B of the Dedekind cuts of x, Φ (S⊕A⊕B) (A) enumerates the Dedekind cuts of f(x).On an enumeration A ⊕ B of x ∈ G, one might hope for it to be computed by a function along the lines of as witnessed by Lemma 4.1.Since this function is S (A) -computable, it would be continuous on its domain.
Unfortunately, this does not suffice for a proof.This function is only defined on generic enumerations of cuts, and no matter which x ∈ R one chooses, there will exist non-generic enumerations of its cuts.Thus, our program above may fail to accept certain enumerations of x, whereas a computable function must accept all of them.To rectify this, we give a slightly more involved program, which will succeed in computing f(x) below an S (A) oracle for every enumeration of each x ∈ R whose left Dedekind cut L x forms an S-generic downward-closed subset of Q.We first describe our program Γ, which "uniformizes" the enumerations A ⊕ B given to it, and then analyze it.
Γ is given the oracle A ⊕ B, along with the fixed set S (A) .At each stage s, it defines the greatest (up to length s) initial segment of a fixed computable listing {q 0 , q 1 , . ..} of Q for which the cuts L x and R x are fully defined by stage s.Then it runs the program Φ for s steps on the given input q ∈ Q, using the oracle s and outputs the same value as this program in case it halts, or else goes back and repeats the same procedure for s + 1. (If, in response to an oracle question from Γ, Ψ fails to halt within s steps using its own smaller oracle, then again Γ starts its own program over at s + 1.)This is the entire program for Γ.
In s steps, Ψ can never ask an oracle question about an element > s, so all oracle values used by Ψ here are exactly as in the canonical enumeration (L x × N) ⊕ (R x × N) of the cuts of x.Thus, if Ψ actually gives an answer (on an input e) using its oracle here, that answer will be identical to the one given by Ψ using that canonical oracle.In case x is generic relative to S, it will therefore tell whether e ∈ (S ⊕ (L x × N) ⊕ (R x × N)) (A) or not.Thus our uniformization to the canonical oracle will have eliminated all uncertainty introduced by the use of the enumeration (A ⊕ B).Moreover, if l s goes to +∞ as s increases, then Ψ will ultimately have access to as much of the canonical oracle as it needs for its computation.Finally, notice that a generic x ∈ R cannot be a rational number, and therefore every q n ∈ Q lies in L x ∪ R x , hence lies in π 1 (A s ∪ B s ) for all sufficiently large s.Thus, for generic x we automatically have lim s l s = +∞, and so Ψ ultimately computes (correctly) as much of (S ⊕ (L x × N) ⊕ (R x × N)) (A) as Φ requires.In short, for every generic x ∈ R and every enumeration A ⊕ B of the cuts of x, the program Γ produces the exact same output as Φ (S⊕A⊕B) (A)  , namely an enumeration of the left and right cuts of f(x), exactly as claimed by the theorem.
Finally, notice that Ψ always uses an oracle that describes (L x × N) ⊕ (R x × N) correctly: the only possible problem arises when x is not S-generic, and even then, Ψ never gives a wrong answer.Therefore, Γ never outputs a wrong answer either: for each q ∈ Q and each enumeration A ⊕ B of any x ∈ R, if Γ halts and outputs 0 on input q, then indeed q ∈ L f(x) ; likewise the output 1 always indicates that q ∈ R f(x) .For an x that is not generic relative to S, the program may fail to halt on various inputs q ∈ Q, in which case that x is not in the domain of the continuous function defined by Γ.However, non-S-generic real numbers form a meager subset of R, so we have proven the theorem.

Lusin's Theorem
Now we may approach Lusin's Theorem.The key lemma, again well-known, is described in more detail in the second appendix (Section 11), as Corollary 11.5.Lemma 6.1 There exists a Turing functional Ψ ε , uniform in the rational ε > 0, such that for every set S ⊆ N and every fixed S-decidable presentation A of any ordinal α < ω S 1 (with α-jumps C (A) defined using this presentation), the "error set" has measure < ε and is an S (A) -effective union of rational open intervals, uniformly in ε, S, and A. Moreover, for all x, Ψ S (A) ⊕Lx⊕Rx ε is total.
Proof As usual, Theorem 3.2 provides Φ, S, and A such that, for every x ∈ R and every enumeration A ⊕ B of the Dedekind cuts of x, Φ (S⊕A⊕B) (A) enumerates the Dedekind cuts of f(x).We wish to construct a Γ, similar to that of Theorem 5.1, that uses The catch is that now we wish the g computed by Γ to have domain R; on the other hand, we may allow g(x) ̸ = f(x) on the error set U ε,S,A given by Corollary 11.5.We write U = U ε,S,A , having fixed the three parameters, and, using Corollary 11.5, fix an S (A) -computable enumeration of rational open intervals whose union equals U. We also fix a computable list q 0 , q 1 , . . . of all rational numbers, without repetitions.It will be convenient to assume that the interval of U enumerated at stage s is of the form (q m , q n ) with m, n ≤ s.This is not difficult to arrange, except that we must allow there to be stages at which no interval is enumerated.
The crucial fact here is the S (A) -computable enumerability of the error set U as a union of intervals with rational end points.This will allow our Γ to recognize these intervals as they appear, at which stage it will abandon its hope of computing a function equal to f within such an interval, and will instead do "damage control" to ensure that it does actually compute a function (necessarily continuous) on each such interval.As long as we make these "damage control" functions meet at the end points of their intervals, we will have continuity everywhere: outside the error set, Γ will compute f(x) successfully, in exactly the style of Theorem 5.1, since Ψ makes no mistakes outside the error set in computing (S ⊕ (L x × N) ⊕ (R x × N)) (A) .
It complicates matters, but it is also liberating, to recall that every rational x must lie in U. (In particular, Ψ will always guess incorrectly about whether the program index e lies in (S ⊕ A ⊕ B) (A) , where, for every input, Φ e halts as soon as the rational x appears in π 1 (A ∪ B).)The complication lies in the fact that, whenever a rational interval (a, b) is enumerated into the error set, the rational a itself must lie in another interval of the error set, as must b, causing these intervals ultimately to metastasize into one long open interval with irrational endpoints, the union of infinitely many overlapping rational intervals in U.The liberation results from the fact that, as in Theorem 5.1, we are again free to ignore the difficulty that, for rational x, L x ∪ R x omits an element (namely x itself).Given an enumeration A ⊕ B of the cuts of an arbitrary x ∈ R, we know that either x will eventually enter the error set (which we can enumerate!)or else As long as x is not yet in the error set, therefore, we are safe in waiting arbitrarily long for the next rational q n on our list to be enumerated by either A or B. If x ever does appear in the error set, we switch to damage control on x.
The bulk of our description of the procedure for the functional Γ deals with the rational intervals (finitely many of them, at each stage s) that currently constitute the error set.
Once we have settled what to do with them, the procedure on the remainder of R is the same one already applied several times.So suppose that as of stage s, our enumeration of U so far consists of rational intervals (a 1 , b 1 ), (a 2 , b 2 ), . . ., (a s−1 , b s−1 ), with each b i < a i+1 .By induction we assume that we have assigned values (as defined below) to all points in the closure U s .This means that we have already determined the finitely many values g(a i ) and g(b i ), possibly along with values g(c) at finitely many other rational c ∈ U s , and that we intend g on U s to be the piecewise linear function that "connects these dots" within each connected component of U s .
Before we describe the action of Ψ on a particular (A ⊕ B), we explain how it sets the scene at each stage s + 1.We have a fixed computable enumeration {q 0 , q 1 , . ..} of Q, so suppose that {q 0 , . . ., q s } is ordered as q j 0 < • • • < q js .These define s + 1 open intervals (−∞, q i 0 ), (q j 0 , q j 1 ), etc, each giving an initial piece of a Dedekind cut: write L i,s = {q j 0 , . . ., q j i−1 } and R i,s = {q ji , . . ., q js }.Ψ runs the programs for each i ≤ s and each k ≤ s, giving up after s steps if there is not yet any convergence.This gives us general constraints on the possible values of f in each interval (q j i−1 , q ji ): an upper bound (possibly +∞) and a lower bound (possibly −∞): If the program in question actually computes f on (q j i−1 , q ji ) correctly, then the values of f there must all lie in (v i,s , u i,s ).Thus the set of boxes (q j i−1 , q ji ) × (v i,s , u i,s ) may be viewed as a tentative approximation of the graph of f in the xy-plane.Of course, this does not take the error set U into account.It could happen that u i,s ≤ v i,s under this definition, if the interval (q j i−1 , q ji ) is contained within U. Also, two adjacent boxes (as described above) might have nonintersecting closures, which again would indicate interference by the error set.Therefore we have only defined u i,s and v i,s here, without using them as yet.
We now continue stage s + 1 by considering the next interval I s = (a s , b s ) to appear in the enumeration of intervals comprising U. We wish to assign g-values to all points x ∈ [a s , b a ].This is the damage-control operation: we have given up on computing f(x) correctly for these points, and merely hope to make g continuous.Within I s this will be easy, but we also need to ensure that our chosen values allow g to be continuous at the boundary of U, where it interfaces with error-free computations of f .(The boundary of U is in fact all the rest of R, since U is dense.) which is decidable from the end points), we do nothing, since values will have already been assigned to all points in U s at preceding stages.Otherwise (I s − U s ) is a finite union of nonempty open intervals, and we treat each of its connected components [c, d] separately.First, if any of the points q j 0 , . . ., q js defined earlier lies in [c, d], then for each such q ji satisfying min(u i,s , u i,s+1 ) ≥ max(v i,s , v i+1,s ), we define: ), then these bounds create an inconsistency at q ji .In this situation we continue to enumerate U until a rational interval (r 0 , r 1 ) containing q ji is enumerated into U. (This must occur eventually, as all rational numbers lie in U.) When this first happens, we define: The argument in the first equation lies below q ji but above each of r 0 , c, and q j i−1 , hence within [r 0 , r 1 ], within the interval where u i,s and v i,s are the upper and lower bounds, and within [c, d], so it is safe to assign to it this g-value between those bounds; similarly for the argument in the second equation.(In case q ji = c ∈ U s , only the second equation applies, as in this case the first equation has argument c and g(c) is already defined.Similarly, if q ji = d ∈ U s , only the first equation applies.)Next, we attend to the end points.If either c or d lies in the closure U s , then it already has been assigned a g-value.If c / ∈ U s , then find the interval (q j i−1 , q ji ) to which it belongs and define , if this is defined; Likewise if d / ∈ U s and d ∈ (q j k−1 , q j k ), then define g(d) exactly the same way, using u k,s and v k,s .The case where c or d actually equals q ji for some i ≤ s was already covered in our first step.

Russell Miller
Now we have defined g on c, on d , and on every q ji in between.We finish by "connecting the dots": simply define g between each pair of consecutive points among these by linear interpolation between the g-values of the two points.
It now remains to describe the procedure followed by Γ with a specific enumeration A ⊕ B of strict Dedekind cuts (of an arbitrary x ∈ R) in its oracle.We use sets A s and B s and the length l s just as defined in the proof of Theorem 5.1.At stage s + 1, Γ searches for the least t ∈ N such that either (1) t > s and l t ≥ s; or (2) there exist m, n ≤ t + 1 such that q m ∈ A t+1 and q n ∈ B t+1 and the open interval (q m , q n ) is enumerated into U by stage t + 1.
If condition (2) holds, then by running the instructions above all the way up to the stage t at which (q m , q n ) is enumerated into U t , we can determine the g-values assigned at that stage to points in this interval.Of course, at this stage we still only have a finite approximation to x, but, knowing the finitely many linear pieces of g on this interval, we can use the approximation given by A s and B s to approximate g(x) in the obvious way.(Notice that this works even if x itself is rational: the fact that some single rational never appears in either Dedekind cut does not stop us from computing g(x).) If condition (1) holds, then from A t and B t we can decide which of the intervals (q j i−1 , q ji ) defined at stage s + 1 contains x.If u i,s ≤ v i,s , then we do nothing at this stage, since then this entire interval must eventually enter U. Assuming u i,s < v i,s , we know that x itself does not lie in U s+1 : condition (1) requires t > s, so if an interval (q m , q n ) containing x had been enumerated into U s+1 , it would have m, n ≤ s (by our convention for this enumeration), and thus stage s would have satisfied condition (2).However, we do not want to deal with an x that is too close to either q m or q n .So we search again, for a stage t ′ such that U t ′ contains both an interval (a ′ m , b ′ m ) that contains q m and also an interval (a ′ n , b ′ n ) that contains q n , and such that either (1a) A t ′ contains a rational number ≥ b ′ m , and If (1b) holds, Γ does not converge on any inputs here, because we know that our x will eventually enter U.If (1a) holds, then Γ halts and outputs 1 for all inputs ≥ u i,s , and halts and outputs 0 for all inputs ≤ v i,s .(Recall that we have checked that v i,s < u i,s .)This means that these values will be upper and lower bounds (respectively) for the real number g(x) ultimately determined by Γ.This completes our description of the program executed by Γ.
It remains to show that Γ S (A) ⊕A⊕B succeeds in computing a function g : R → R, as A ⊕ B varies over all enumerations of Dedekind cuts, and then that g(x) = f(x) outside of the error set U (which we know has measure < ε).Being computed by Γ this way, g will necessarily be continuous.
To see this, fix any x ∈ R and any enumeration A ⊕ B of the cuts L x and R x of x.Suppose first that x ∈ U.Here we do not claim that g(x) = f(x), but we do show that Γ S (A) ⊕A⊕B computes the same real-number output g(x) regardless of the enumeration of x.Indeed, since x ∈ U, there is some interval I s 0 = (a s 0 , b s 0 ) with x ∈ I s 0 enumerated into U at some stage s 0 .Notice that at every subsequent stage s > s 0 , condition (2) will hold with t = s 0 − 1, while condition (1) can only be applied at stage s + 1 if t > s; thus the instructions for condition (1) will never be followed again.Moreover, regardless of the choice of enumeration A ⊕ B of L x and R x , we will recognize from stage s 0 + 1 onwards that the enumeration of I s 0 into U has placed us in condition (2).Therefore, from stage s 0 + 1 on, Γ will always proceed with the computation of the assigned value g(x), based on the linear functions chosen at stage s + 1 for the interval of U s containing x.Of course, the computation of these linear functions (with rational coefficients, no less!) is effective regardless of the enumeration A ⊕ B, and the end points of the linear function were selected specifically so that no upper or lower bounds enumerated by Γ at preceding stages could possibly contradict the value g(x) assigned to any x in the interval, including our specific x.It is also important to note here that we never assigned contradictory information in the computation of g(x), even when using condition (1).All rationals enumerated into the lower cut of g(x) were checked to be less than all rationals enumerated into the upper cut.Moreover, as long as condition (1) applied, the same rationals were enumerated into each cut independently of the specific enumeration A ⊕ B. The choice of A ⊕ B only affects the stage at which the computation permanently switches over to condition (2), which occurs at or before stage s 0 , and the scene-setting procedure included a check that all upper and lower bounds enumerated for values x in I s 0 are consistent with the choice of g(x).Therefore Γ does compute the same value g(x) independent of the specific enumeration A ⊕ B of the cuts of x.This is all that we require of Γ on an x ∈ U: the damage-control procedure succeeded.
The other case occurs when x / ∈ U. Now the procedure above never acts on condition (2).Since every rational number lies in U, it follows that x / ∈ Q, so every q m lies in L x ∪ R x , and thus the length l s of the approximation A s ⊕ B s goes to +∞ as s increases.Consequently, for every stage s, there does exist some t > s with l t ≥ s.

Now since x /
∈ U, Φ does enumerate the cuts of f(x) when it runs with the oracle set Ψ S (A) ⊕(Lx×N)⊕(Rx×N) .Therefore, for any specific rational u > f(x) and v < f(x), there exists some s 0 such that Φ with this oracle enumerates u into the upper cut and v into the lower cut, in at most s 0 steps, using only the initial portion ((L x ↾ s 0 ) × N) ⊕ ((R x ↾ s 0 ) × N) of the oracle of Ψ.But l t → +∞ as t increases, so at every stage ≥ s 0 , running Γ with the oracle A ⊕ B will produce this much of L x and R x .Now fix some m, n > s 0 such that x ∈ (q m , q n ) but no q k with k < max(m, n) lies in (q m , q n ).When we reach stage s + 1 with s = max(m, n), this interval will be the i-th interval in the partition of R (that is, m = j i−1 and n = j i at this stage), and so the bounds u i,s and v i,s determined at that stage will have f(x) < u i,s ≤ u and f(x) > v i,s ≥ v.Moreover, since x / ∈ U, condition (1b) must hold (at this and all other stages), and so u i,s and v i,s are enumerated into the upper and lower cuts of g(x) at that stage if not before, no matter what input A ⊕ B enumerating the cuts L x and R x is used.With v < v i,s and u i,s < u, this makes it clear that Γ enumerates our original (arbitrary) u and v into the correct cuts.Therefore, on all inputs A ⊕ B enumerating L x and R x , Γ does compute g(x) = f(x) as required.

Uniformity
It was not the original purpose of this article to prove anything new.The intention was to present a new proof of Lusin's Theorem in real analysis, using known facts from computability theory and descriptive set theory, and thus to illustrate and illuminate a connection between the principles used in standard proofs of Lusin's Theorem and the principles from computability which make our proof here work.Nevertheless, certain uniformities and computability results became apparent during the creation of the proof in Section 6, and in the end we have an effective version of Lusin's Theorem.Sometimes new ideas entail new results, even when not intended to do so.
The substantial uniformity in the creation of g from f in our proof of Theorem 6.2 yields the function h that we describe here.Similar uniform versions hold for our simpler results in Theorems 4.2, 4.5, and 5.1.Theorem 7.1 There is a computable total function h : Q × N → N such that, for each fixed α and S and each S-decidable presentation A of α, whenever an α-jump-computable function f is given by the oracle computation e for all enumerations A ⊕ B of the cuts of each x ∈ R, the function g(x) defined by realizes Lusin's Theorem 6.2 for this f and an arbitrary rational ε > 0.Here E(A) is the elementary diagram of A, given as a subset of N by a Gödel coding.
That is, the Turing functional for computing g can be determined uniformly from that for f , uniformly in ε and independently of the level of f in the Borel hierarchy up to α.
By the Padding Lemma (see eg Soare [6, Lemma I.3.2]),h may also be assumed injective.Of course, h only describes how to determine the program for computing this g.In order to compute g, one also needs the oracle S (A) and the elementary diagram E(A) of the linear order A. However, the choice of program for g depends only on ε and the program given for computing f , not on which S and A are used to compute f .In fact, not all of the atomic diagram E(A) is required as an oracle; it suffices to know which elements of (A, ≺) are limit points from the left, which is the zero element, which pairs (m, n) are adjacencies (with m ≺ n and no elements between them), and whether A itself is a limit ordinal, a successor, or zero.For uniformity, though, even the finite information, such as knowing which element is the left end point of A, must be given.Finally, it is not necessary to be given this diagram itself: since an S-oracle is given, one only needs to know an index for computing this information about A from S.
Nowhere in the proof of Theorem 6.2 did we use the fact that the values f(x) were finite real numbers (as opposed to ±∞).Indeed, the same proof would work even if enumerations of improper Dedekind cuts were allowed as outputs.Moreover, the construction in Theorem 6.2 ensures that the points x where g(x) ̸ = f(x) all have g(x) finite, as they all lie in U, which is the union of intervals on which g is defined to be finite.

The Causes of Discontinuity
Our proof of Theorem 6.2 emphasizes a remarkable fact about Lusin's Theorem.Once the parameters ε, S, and A are fixed, the proof uses the exact same error set U ε,S,A for every function f it is given.So one may legitimately argue that the non-continuity of functions f at this level of the Borel hierarchy is the "fault" of the real numbers x in namely, the set of those x ∈ R that are not generalized-α-low relative to S (using the presentation A of α).In this sense, the functions themselves are not the obstacle: their non-continuity was caused by our inability to approximate (S ⊕ L x ⊕ R x ) (A) for those x in the error intervals.Proposition 8.1 Fix α, S, an S-decidable presentation of α, and a rational ε > 0. Then for every α-jump S-computable function f : R → R, the procedure in Theorem 7.1 produces a continuous g such that the set {x ∈ R : The immediate objection to this proposition is that, just by translating f by a certain fixed parameter c, one could define a function f c (x) = f(x − c) for which most of the discontinuities of f move out of U ε,S,A .This is true, but it requires c to be noncomputable, indeed not S-computable, and so f c does not belong to the class of functions considered in Proposition 8.1.In fact, U ε,S,A is closed under translation by S (A) -computable parameters, and under other similar gambits one might concoct.
The more informed objection to the proposition is that it is obvious: there are only countably many α-jump S-computable functions, so by applying Lusin's Theorem to the n-th such function with tolerance ε/2 n+1 , we immediately prove the proposition.This is correct, but the spirit of the proposition is that it was not necessary to slice up the ε-amount of measure this way: our proof of Theorem 6.2 defined U ε,S,A using basic computability theory, and then uniformly constructed some continuous g for each f such that they differed only within U ε,S,A .Probably the best way to express this is to note that the restriction of every such f to the complement of each U ε,S,A is itself S (A) -computable and hence continuous on this domain, and that each such domain is simply a Π S (A) 1 set of real numbers.
In contrast, however, the restriction of such an f to the complement of U S,A (defined just above) need not be continuous.Analogously, while only measure-0-many real numbers fail to be generalized-α-low relative to S, no single Turing functional can compute (S ⊕ X) (α) from S (α) ⊕ X for all but measure-0-many X .As an example of a 2-jump-computable function f such that no restriction of f to a set D ⊆ R of full measure is continuous on the domain D, consider: The set (L x ⊕R x ) ′ is c.e. relative to (L x ⊕R x ), hence uniformly decidable using the oracle (A ⊕ B) ′′ whenever (A ⊕ B) enumerates the cuts of x.Thus f is 2-jump-computable.
Russell Miller L q and R q are computable uniformly in Q, so (S ⊕ L q ⊕ R q ) (A) is S (A) -computable, uniformly in q, and an (S ⊕ L q ⊕ R q ) (A+1) oracle can decide the set: The elements of D are "boxes" (a, b) × (v, u) in R 2 within which the graph of f (restricted to (a, b)) must lie.Now for any x ∈ R and any enumeration A ⊕ B of the cut of x, we get an S (A+1) -computable enumeration of: By continuity there are boxes in D with u − v arbitrarily small, and so the projections p 3 and p 4 of E x are the right and left cuts R f(x) and L f(x) .Thus we have a computation of f below an S (A+1) -oracle, whose program is uniform in the index e.
10 Appendix: Computable functions on R Turing computability normally applies to functions from N, the set of all nonnegative integers, into itself.By fixing a computable bijection between N and Q, we may equally well consider functions Q → Q, or Q → N, or N → Q.We also use a standard computable bijection ⟨m, n⟩ mapping N × N onto N, and similarly for Q.
We write a, b, q, r, u, v and sometimes ε for rational numbers, and a, b, r, x, y for real numbers.Real numbers correspond bijectively to Dedekind cuts under their usual definition: nonempty downward-closed proper subsets of Q with no greatest element.For our purposes, this definition must be adapted slightly.
We also define generalized Dedekind cuts to include the pairs (∅, Q) and (Q, ∅), corresponding to −∞ and +∞, in addition to the proper Dedekind cuts defined above.
An enumeration of a generalized Dedekind cut (L, R) is a set that, when expressed as a join A ⊕ B, satisfies π 1 (A) = L and π 1 (B) = R, where π 1 (⟨q, n⟩) = q is the projection map.The canonical enumeration of (L, R) is the join It is natural to regard A and B as subsets of Q × N, so that an oracle for A ⊕ B allows us to list out the elements in the projections of A and B, and thus to enumerate both the lower cut and the upper cut of the real x.
We can now give a definition of computability for functions on R using Dedekind cuts, instead of the usual fast-converging Cauchy sequences, to represent real numbers.Definition 10.2For each subset S ⊆ N, a function f : R → R is S-computable if there exists a Turing functional Φ such that, whenever X is an enumeration of the Dedekind cut of any x ∈ R, Φ S⊕X is the characteristic function of an enumeration of the Dedekind cut of f(x).
It is equivalent, and often simplifies matters, to have Φ S⊕X be a partial function from Q into {0, 1}, understanding {q : Φ S⊕X (q) ↓= 0} and {q : Φ S⊕X (q) ↓= 1} to be the left and right Dedekind cuts of f(x), respectively.In this case, if f(x) itself is rational, then Φ S⊕X (f(x)) never halts.
The possibility that L ∪ R omits an element of Q is the reason for considering enumerations of cuts.If we had simply taken L as an oracle, rather than an enumeration of (L, R), then for rational q, the characteristic function of the interval [q, +∞) would have been computable; similarly with R and the interval (−∞, q].On the other hand, if we had required the cut of a rational y to include y itself on one side or the other, then functions such as f(x) = x 2 − 2 would not be computable.(For that f , given an enumeration of the cuts of x = √ 2, Φ would never be able to place the rational 0 with certainty on either side of the cut of f( √ 2).) Classically it is standard to express Definition 10.2 using fast-converging Cauchy sequences instead of Dedekind cuts.(A Cauchy sequence ⟨q n ⟩ n∈N converges fast to x = lim n q n if, for every n, |q n − x| < 2 −n .)Readers will understandably be baffled at first by our choice to use enumerations of Dedekind cuts as inputs and outputs of functions, rather than following tradition.We request forbearance: in our view, this is the simplest way to prove Theorems 5.1 and 6.2, because (as suggested in Definition 10.1) it affords a canonical enumeration of the Dedekind cuts of each x, whereas in general no Cauchy sequence converging fast to x is identified as the canonical such sequence.Were it not for the simplification of the proofs of these theorems, we would gladly use the traditional definition, which has proven appropriate for all work so far in computable analysis.
Definition 10.1 makes Definition 10.2 equivalent to the usual definition of computable functions on R. The next lemma proves this, by showing that we can pass effectively between the different methods of representing real numbers.
Lemma 10.3There exist Turing functionals converting each of the following representations of real numbers x into the other: • An arbitrary enumeration of a Dedekind cut for x in Q.
• An arbitrary Cauchy sequence that converges fast to x.
Proof The lemma states that, for example, there exists a Turing functional Υ such that, whenever A ⊕ B is an enumeration of the Dedekind cuts in Q for some real number x, Υ A⊕B will be a Cauchy sequence converging fast to the same x.Indeed, given an enumeration A ⊕ B of the cut of some x, on input n, Υ searches for ⟨a, s⟩ ∈ A and ⟨b, t⟩ ∈ B with b − a < 1/2 n−1 .For the first such pair of pairs to be found, it outputs q n = (a + b)/2 as the n-th term.Since x ∈ (a, b), this q n is strictly within 1/2 n of x, so ⟨q n ⟩ n∈N converges fast to x. (This is the definition of fast convergence: ) Conversely, given any Cauchy sequence ⟨q n ⟩ n∈N converging fast to x, the set enumerates the Dedekind cuts of x.
With Lemma 10.3 it is clear that the well-known theorem of Weihrauch holds for the functions of Definition 10.2.
Theorem 10.4 (Weihrauch [8]) A function f : R → R is continuous if and only if there exists a set S ⊆ N such that f is S-computable in the sense of Definition 10.2.
11 Appendix: Approximating the Iterated Jump In this appendix we describe known concepts and results that may be unfamiliar to readers outside computability theory, and also describe the precise version of the iterated jump used in this article.By definition, the jump, or Turing jump, A ′ of a set A ⊆ N is the relativization of the Halting Problem to the set A: A ′ = {e ∈ N : Φ A e (e) halts} Here Φ 0 , Φ 1 , . . . is the standard enumeration of all Turing functionals, that is, of all programs for Turing machines endowed with an arbitrary "oracle set" of natural numbers.One writes Φ A e for the partial function from N into N computed by the e-th such program when using the set A as its oracle.We refer the reader to Soare [6, Chapter III] for full definitions.The set ∅ ′ is essentially the Halting Problem itself, and just as ∅ ′ is not computable, so likewise A is always strictly below A ′ in Turing reducibility: A < T A ′ , by which we mean A ≤ T A ′ but A ′ ̸ ≤ T A. (It is not completely obvious that one can compute A using an A ′ -oracle, but the proof is not difficult.) The jump operator is simply the function A → A ′ , sending each subset of N to its jump, and thus mapping the power set P(N) into itself.This map is injective but not surjective, and it preserves Turing reductions but can fail to preserve non-reductions: the implication always holds, but its converse can fail.Since the jump operator maps P(N) into itself, it is natural to iterate it.We write A (k+1) for the jump of A (k) , with A (0) = A, thus defining all finite jumps of each set A.
However, this is not the end of the iteration.For ω , the first infinite ordinal, the ω -th jump A (ω) of a set A is a sort of union of all the preceding jumps of A: One views the k-th jump of A (for each k) as being coded into A (ω) as the k-th column, under the usual computable bijection from N 2 onto N mapping the ordered pair (n, k) ∈ N 2 to its code number ⟨n, k⟩ ∈ N. Clearly no finite jump A (k) can compute A (ω) , since if it could, it would then compute the (k + 1)-st column A (k+1) , contradicting the fundamental property of the jump operator.We view A (ω) as a natural "next" jump, in the sense of ordinals, after all finite jumps have been built.(To be clear: the set ω is actually just the set N, but now viewed as an ordinal.) Nor yet is this the end of the process.One now continues through successor ordinals as before, with A (ω+1) = (A (ω) ) ′ and so on.At subsequent limit ordinals λ, it is not always as obvious as for ω exactly how to define the λ-th jump, but we can do so if given a computable presentation of the ordinal λ-that is, a computable linear ordering ≺ of the domain N such that (N, ≺) is isomorphic to λ as a linear order.(Later we will assume that in the order ≺, the successor and limit relations are computable as well.)Then we can define the k-th column of A (λ) to represent the α-th jump A (α) , where k ∈ N is mapped to α ∈ λ by the isomorphism from (N, ≺) onto λ.This gives a reasonable notion of A (λ) , except that it depends on the choice of the presentation ≺ of λ.With proper use of ordinal notations, one can now define the set A (α) for all ordinals α with computable presentations, and, although the actual set depends on the notation chosen.its Turing degree does not.
Church and Kleene knew that there must be a countable ordinal with no computable presentation, and the least such ordinal is now known as ω CK 1 .Iterating the jump to A (ω CK 1 ) and beyond requires presentations of noncomputable ordinals.In the work in this article, we are generally able to use as oracle a (noncomputable) set S capable of giving presentations of noncomputable countable ordinals.Of course, for each S there is a least countable ordinal ω S 1 which has no S-computable presentation (and it then follows that no ordinal > ω S 1 has any S-computable presentation either).On the other hand, every countable ordinal is isomorphic to some linear order on N, just by the definition of countability, and so, for every countable α, there is some oracle set S such that α < ω S 1 , ie such that α has an S-computable presentation.(Again, we will need a slightly stronger presentation of α, with successors and limits known, but with the right oracle this can also be assumed.In fact, Spector showed that S itself can give such a presentation.)Thus we have (sketchily) described the iterated notion of the jump operator.Having done so, we will now give formal definitions for use in this article.
Definition 11.1 A presentation A of a nonzero ordinal α < ω 1 is a linear order A = (D, ≺) isomorphic to (α, ∈), whose domain D is a coinfinite subset of N and whose least element is the number 0 in N. The presentation A is S-decidable if S can compute the complete diagram of A.
A presentation is normally called S-computable if S can compute its atomic diagram.We will need more than just that here, and we could be more precise (as above) about the exact information we require S to compute: the successor function on A, the existence of a greatest element in A, and the unary relations on A of having no immediate predecessor and of being the least or the greatest element of A. Demanding that S compute the complete diagram is overkill, but keeps the definition simple.The requirement that D be coinfinite is unusual in computable structure theory, but helpful for our purposes here: we will need it when α is a successor, in order to have a location in which to code one more jump.
It is important to notice that, for every nonzero k ∈ D, the substructure B k with domain {j ∈ D : j ≺ k} is a presentation of an ordinal β k < α, and that each β < α is isomorphic to β k for some unique k ∈ D.Moreover, S can compute the complete diagram of each B k , uniformly in k.
Definition 11.2For a presentation A of a nonzero ordinal α < ω 1 , the A-jump C (A) of a set C ⊆ N is the subset of N containing those codes ⟨k, n⟩ for pairs (k, n) such that either • k ∈ dom(A) and n ∈ C (B k ) ; or • A has a ≺-greatest element j and k is the least number > j in D and: The ordinal α = 0 has only one presentation A 0 , with empty domain, and we define C (A 0 ) = N × C for every set C ⊆ N.
So, for k ∈ D, the k-th column of C (A) is simply the set C (B k ) , meaning that for every β < α, the β -th jump of C (under the presentation B k ) appears as the k-th column.If α is a limit ordinal, all other columns are empty, but for a successor ordinal α = β + 1, with j the greatest element of A, the k-th column of C (A) (for to the least number k > j in D) presents the α-th jump of C (under the presentation A).With D coinfinite, such a column does exist and is found using the diagram of A.
Notice that the 0-th column {n : ⟨0, n⟩ ∈ C (A) } of C (A) is just the set C itself, for every presentation A of any ordinal, because 0 is always the least element of the presentation.This gives us a uniform way to recover C from C (A) , independent of the presentation.
When α = m is finite, C (A) is not literally the same set as the jump C (m) discussed above, but for our purposes in computability they are equivalent: one column of C (A) actually is the set C (m) , all others are computable from C (m) , and we have a 1-reduction from the k-th column to C (m) uniformly in k.More generally, for a presentation A of a successor α = β + 1, one can view C (A) as the jump of C (B j ) , where j is the greatest element in A: this essentially says that the α-th jump is the jump of the β -th jump.(C (B j ) itself also appears inside C (A) , just as the β -th jump is 1-reducible to the α-th jump.)The uniformity of Definition 11.2 across finite and infinite ordinals will simplify our arguments below.
The key property used in this article is that, for a fixed oracle set S, "most" sets A satisfy (S ⊕ A) ′ ≤ T S ′ ⊕ A, and that this reduction is uniform for most of those sets A. It is impossible for this to hold for all A (and in particular for A = S ′ ), but it does hold for all 1-generic sets A, as seen the proof of Lemma 4.1 above.For Lebesgue measure on 2 N , Theorem 2 of Stillwell [7] proves that a Turing reduction A ′ ≤ T ∅ ′ ⊕ A exists for measure-1-many sets A. It is not uniform on any set of full measure.(That is, no single functional Φ suffices, even up to a set of measure 0.) Since we wish to address functions on R as well as on 2 N , we need a more specific theorem, using only (strict) Dedekind cuts L ⊕ R of real numbers as our oracles.Since the set of all such cuts has measure 0 under Lebesgue measure on Cantor space (viewed here as 2 (Q⊕Q) ), we must re-prove the result of [7] for our own measure, namely Lebesgue measure on R.
The first lemma is a warm-up for the main theorem, demonstrating the basic technique.Fix a computable enumeration q 0 , q 1 , . . . of all rationals in the interval (0, 1).We write L x for the strict left Dedekind cut of a real number x, and R x for its strict right cut.For each a = q j and b = q k in Q such that 0 ≤ a < b ≤ 1 and every q i ∈ (a, b) has i > max{j, k}, we define the binary strings λ a,b and ρ a,b each to have length l, where l Russell Miller is least with q l ∈ (a, b), and set: Thus the real numbers x in the open interval (a, b) are precisely those x such that λ a,b is an initial segment of L x (viewed as an infinite binary string) and ρ a,b is an initial segment of R x .(These strings are examined further at the end of the proof of Theorem 11.4.)For intervals (a, b) where some q i ∈ (a, b) has i < j or i < k, it is possible to divide the interval into finitely many subintervals with the property required above, effectively, and to consider a string λ ⊕ ρ for each subinterval.
Proof Given an e ∈ N, Ψ S ′ ⊕Lx⊕Rx ε searches for a rational number r ∈ [0, 1], a finite initial segment σ ⊂ S, and a finite collection (a 0 , b 0 ), . . ., (a m , b m ) of disjoint open rational subintervals of (0, 1) and a stage s such that: • (∀i ≤ m) Φ σ⊕λ ai,bi ⊕ρ ai,bi e,s (e) ↓ • i≤m (b i − a i ) > r • there do not exist a number t, a τ ⊂ S, and finitely many disjoint rational intervals (c 0 , d 0 ), . . ., (c n , d n ) within (0, 1) such that i≤n (d i − c i ) ≥ r + ε and (∀i ≤ n) Φ τ ⊕λ ai,bi ⊕ρ ai,bi e,t (e) ↓ The S ′ -oracle allows Ψ ε to recognize the truth or falseness of the final statement for any specific r, while the first two statements are decidable.For the r that is found, we have r < µ {y ∈ (0, 1)Φ S⊕Ly⊕Ry e (e) ↓} ≤ r + ε/2 e+1 .(This also makes it clear why such an r must exist: arbitrarily much of the measure of this set can be covered by finitely many initial segments of oracles L x ⊕ R x .)Now Ψ ε examines the L x ⊕ R x -portion of its oracle.If, for some i ≤ m, λ ai,bi ⊕ ρ ai,bi ⊆ L x ⊕ R x , then it outputs 1, since such an x will lie in one of the intervals (a i , b i ).For all other x it outputs 0, meaning that it thinks that Φ S⊕Lx⊕Rx e (e) ↑ .This output 0 may be wrong for certain values x, but only for ε/2 e+1 -many.Since this holds for every e, incorrect outputs can only occur for at most ε-much of the interval (0, 1).Moreover, it is clear that this procedure is uniform in ε > 0.

Russell Miller
For elements k / ∈ D, the program checks whether any j < k is the greatest element of A, and if so, whether k is the <-least number in D greater than that j.If not, then it immediately outputs 0. If so, then it runs in a similar manner to the program in Lemma 11.3, recursively using the column J = {⟨ j, n⟩ : n ∈ N} of its own output.For definiteness we specify that on input ⟨k, e⟩ (with k / ∈ D) it uses a tolerance of ε/2 k+e+2 to approximate J ′ .
Since ≺ well-orders A, it is readily seen (by induction on columns whose numbers lie in D, ordered according to ≺) that this program halts on every input ⟨k, n⟩ with k ∈ D. If α is a successor, the same proof then applies to the k / ∈ D determined above, and for all other k / ∈ D it halted immediately.So the program Ψ ε with arbitrary oracle S (A) ⊕ L x ⊕ R x always computes a total function.Next we consider the set U ε,S,A of those L x on which it fails to compute (S ⊕ L x ⊕ R x ) (A) .This can happen in many ways.For the very first jump, when k 1 is the second-to-left point of A, the computation on input ⟨k, e⟩ will be incorrect on a set of x of measure < ε/2 2+k 1 +e , and so the set of those x for which there is an error anywhere in this column has measure < ε/2 k 1 +1 .For the second jump, in column number k 2 , there are two reasons the computation could be incorrect: either x lies in the set of measure < e ε/2 2+k 2 +e = ε/2 1+k 2 on which the approximation goes wrong, or else the approximation was using an incorrect version of (S ⊕ L x ⊕ R x ) (B k 1 ) from column k 1 .However, we already counted those x for which the k 1 column was incorrect, so the reals x added to the set U ε,S,A on account of column k 2 have total measure < ε/2 1+k 2 .Similarly, for every x in U ε,S,A , either there is some ≺-least k ∈ D such that the computation for x goes wrong in column number k, or else α is a successor and the computation went wrong in column k = min(D).Therefore, the total measure of U ε,S,A is at most e (e); if it does so incorrectly, then this x was already enumerated at the previous step, while

Theorem 5 . 1
Let f : R → R be a Borel function.Then f restricts to a continuous function g whose domain is the (comeager) set G containing all elements of R that are generic relative to S.
The foregoing paragraph already essentially explained how we can uniformly enumerate the open set U ε,S,A from an S (A) -oracle.Those x in U ε,S,A for which the first column k 1 was incorrect all have Ψ S (A) ⊕Lx⊕Rx ε (e) = 0 for some e such that eventually Φ (S⊕Lx⊕Rx) e (e) halted.With the S (A) -oracle we can run both of these computations with arbitrary strings of the form λ a,b ⊕ ρ a,b in place of L x .When we find any λ a,b ⊕ ρ a,b and e for which Ψ ε (e) gave 0 but Φ S⊕λ a,b ⊕ρ a,b e (e) ↓, we enumerate the open interval (a, b) of R into U ε,S,A (since all x there have λ a,b ⊕ ρ a,b ⊆ L x ⊕ R x ).For column k 2 , we do the same, using Ψ S ′ ⊕Lx ε to compute the oracle for the computation Φ (S⊕Lx⊕Rx) (B k 1 )