It is easy to see that no n-REA set can form a (non-trivial) minimal pair with and only slightly more difficult to observe that no ω-REA set can form a (non-trivial) minimal pair with . Shore has asked whether this can be improved to show that no ω-REA set forms a (non-trivial) minimal pair with . We show that no such improvement is possible by constructing an ω-REA set C with forming a minimal pair with . We then show that no α-REA set (for any notation α) can form a (non-trivial) minimal pair with .
The notation we use in this proof is largely standard. We use to denote finite partial functions from ω to and write to denote that the function τ extends σ. We identify sets with their characteristic functions so that has the expected meaning for and use capital roman letters to range over subsets of ω or partial functions (from ω to ) understood as pieces of such sets.
We say σ is incompatible (compatible) with τ, denoted (), if there is some (no) with . We regard functions as sets of ordered pairs so if then gives us the least common extension and ∅ denotes the empty partial function. We let range over elements in , write for the parent of α and let range over children of α. We denote the length of a α by and the concatenation of α with β by . In the special case β is the function of length 1 sending 0 to x we abbreviate by .
denotes the e-th valued partial computable functional applied to oracle Z on the input x. We adopt the convention that if converges in s steps, written , then . is the e-th set c.e. in Z and is its stage s approximation. We use to denote the integer code of the pair and assume, for the complement of C, for the jump of C and for Turing reducibility, equivalence, meet and join respectively. We adopt the usual abuse of notation allowing us to write with the obvious meaning. We follow the standard practice of identifying , the n-th column of X, with and for . We extend this notation to partial valued functions on ω in the obvious manner and stipulate that .
Overview
In [1] Jockusch and Shore introduce the α-REA sets (for ) as the sets produced by effectively iterating the construction of a relatively c.e. set α many times. Since we will restrict our attention here to we will use an equivalent (up to Turing degree) definition.
is ω-REA iff there is a computable function f such that .
Professor Shore has observed that if is ω-REA then with but asked (private communication) if this would still hold if was replaced with . In this paper we answer this question in the negative by proving the following theorem.
There is an ω-REA setsuch that.
Failure at
Before we embark on this construction it is instructive to see why this claim fails for .
If C is ω-REA andthen.
Assume C fails the lemma. We first argue that for every n, must be computable. Since is in if n is maximal integer with we must have . Hence if then for all .
So suppose for all . We now argue that can compute C. Note that given a c.e. index for a computable set R, can recover a c.e. index for and from c.e. indexes for and a c.e. index for is uniformly computable. Thus, if is computable for all , by induction, can recover with . Clearly these indexes allow to compute C. □
The lesson to be drawn from this proof is that any C satisfying Theorem 1.2 must be the join of a countable collection of computable sets. Thus the non-computability of C must result from the non-uniformity of this join. The difficulty in building C is therefore how to encode enough about in so can successfully diagonalize against the sets while making sure only encodes a finite amount of non-computable information.
Machinery
Building ω-REA sets
Evidently if we are to build we will need to uniformly specify a c.e. procedure for building from while dealing with the fact that our approximation to will never settle on the correct value. Rather than trying to explicitly give such a procedure upfront we will instead enumerate rules, called axioms, committing us to enumerate certain elements into when certain conditions are met by .
A axiom is a triple where , σ is a function from a finite subset of to and .
We think of the axiom as a commitment to place y in C if . The parameter l serves only to ensure that attempts to enumerate elements in the n-th column of C are only allowed to consult the first columns of C, thus avoiding any circularity. The utility of this definition is made clear by the following lemma.
Ifis a c.e. set of axioms then the set C defined bythenis ω-REA.
Note that
Thus only depends on so C is well defined. Furthermore, the above equation explicitly defines from and n via a (uniformly) formula. Thus, by an application of the s-m-n theorem [2] there is a computable function f satisfying Definition 1.1. □
Our construction will proceed by building a c.e. set of axioms which will yield an ω-REA set via the preceding lemma. To make proper use of this machinery we introduce two more definitions. We first try and capture the notion that some axiom only has an effect if .
The axiom depends on σ if . We say the axiom is enumerated dependent on δ to mean we enumerate into .
We will also speak loosely of an element being enumerated as shorthand for the axiom being enumerated. We will also say that an axiom is enumerated dependent on (or just n) when the axiom is enumerated dependent on the partial function σ defined by . Finally, we say an axiom is compatible (incompatible) with a partial function τ just if σ is compatible (incompatible) with τ.
During our construction, we will frequently want to satisfy some requirement on the assumption that C behaves a particular way on some domain. In particular, our construction will make guesses about the behavior of C on some finite number of columns supplemented by a finite number of additional locations. We, therefore, introduce a notion of how the axioms would affect C if such a guess were correct.
Given any partial function τ we say that a set of axioms yields over τ just if
Given compatible partial functions and δ we say that yields C over when yields C over .
In other words yields C over just if we assume that C really does extend both and δ (ignoring any axioms to the contrary) and apply the construction from Lemma 2.2 starting from . The fact that axioms1
In the above equation we presume that all elements in are valid axioms.
are only allowed to reference prior columns ensures not only that C is well defined but also that, if is finite, then C can be uniformly computed from and . Sometimes we will informally talk of yielding σ over when it yields .
Requirements & modules
We fix a computable array of sets via the limit lemma [5] such that every set is of the form and build C to meet the following requirements.
We reserve columns , for and the column for meeting and grant each requirement the right to modify a finite initial segment of later columns but not earlier columns. Each column of C will be either finite or co-finite thereby making computable as our observation above required.
As C can’t be computable in during the construction later requirements won’t know, even in the limit, how the earlier requirements are satisfied. To deal with this we perform our construction along a tree, assigning to each in the tree a module of the form or tasked with handling a particular requirement on the assumption that α correctly encodes how the higher priority requirements are met. In particular we assign requirements to modules as follows.
Given we define to be the first column reserved for the requirement handled by the module at α. Note that only depends on , so all modules tasked with meeting a given requirement share columns and as iff the descendants of β can’t affect . In other words, if α implements () then all nodes of length share the columns (column ) and all nodes of length share the column (columns ). Note that, while every node only directly acts to modify C on the columns reserved for it, the module can indirectly affect locations in latter columns by enumerating elements which affect the application of axioms enumerated by nodes of longer length.
Action along the tree
As explained above the module at α will act to meet its requirement using the information encoded in α about how earlier requirements were met. At each stage we will have some guess at how the various requirements are met, and that guess will control which modules are executed at that stage, i.e., only those modules that appear to have correct guesses execute. The resulting construction takes the form of a standard priority tree argument as described in [6].
We remind the reader that a priority tree seeks to define a function f, the truepath, such that if then indicates how the module at α satisfies its associated requirement. At each stage s, we build an approximation to the truepath by inductively defining to be the outcome selected by the module located at at stage s, provided this isn’t the first time that is visited. Note that our choice of differs from the notation used in [6], as does our decision to limit the length of so that only a single previously unvisited node is visited each stage.
The construction
A full description of the construction will consist of giving the behavior of each module , the approximation to its outcome and (computably) associating to each node α a (index for a) computable partial function with domain and a finite partial function . The partial computable function represents a guess at the first columns of C, and represents a guess at the behavior of C as a result of axioms enumerated (by incompatible nodes) before α is visited (as impacted2
For instance, if α implements a module of the form then both and build on by capturing the effect of axioms previously enumerated by nodes extending but the differing predictions these nodes make on column affect which of these axioms succeeds in their enumeration.
by the action of nodes ). Note that we will ensure that and are always compatible and that whenever then and .
The partial function will also play a secondary role as a restraint on nodes , as no node α is allowed to enumerate axioms attempting to place into C. By ensuring that includes the use of any computations being preserved by , we will avoid any injury by descendant nodes. Note that, while both and are functions only of α and don’t depend on the stage, they aren’t defined until the first stage at which α is visited. This allows both and to accommodate actions taken before α is visited, which will be critical to accommodate the other modules sharing the same columns.
Basic approach
The global construction is a standard priority tree construction in which we try to ensure that if then the modules at α and β don’t interfere. Ideally, this would be accomplished simply by ensuring that whenever then . By always enumerating any axiom produced by the module at α dependent on , this would allow us to ensure only axioms enumerated along the true path have any effect on C.3
At least on the assumption, which we will later vindicate, that .
However, we can’t accomplish this without disrupting computations we need to preserve.4
In particular, couldn’t commit to placing z in C only if it observes incompatible approximations to since enumerating z could destroy the incompatible approximations.
So, instead we will ensure a weaker condition which will ensure that, after α is first visited, it can ignore axioms subsequently enumerated by incompatible nodes β and that those axioms it can’t ignore have their effect safely confined to . Specifically, we will satisfy the following condition.
The following hold for any node α.
Suppose , and with then .
If but then any y mentioned in an axiom enumerated by β before α is visited satisfies .
Before giving a precise account of each module’s behavior we informally sketch our strategy for meeting each requirement in isolation. The module works to meet as follows.
Initially, picks some outside of but in the column designated for α’s use. This allows to hold y out of C to ensure , as long as y doesn’t enter . If y does enter the module enumerates y into C to ensure . This guarantees is satisfied while imposing what a simpler construction would call finite injury, but in a priority tree construction corresponds to the approximation to the truepath shifting left to visit virgin copies of any lower priority modules.
The module working to satisfy provides a more interesting case. Here our strategy will be to lay dormant (unactivated) as long as the action of nodes never leads us to change our mind about (our approximation to) , i.e., flip the value of for some x. If our minds are never changed, we will argue that is computable. If we do see a change in our approximation, say at , we will activate and steer C towards whichever possibility ensures that . Should the value of change at a latter stage, we steer C towards the other approximation. Assuming we can change our minds as many times as we wish, we either succeed in diagonalizing against or changes its mind infinitely often and isn’t defined. Either way we satisfy .
This leaves us two challenges. First, ensuring that if α’s approximation to ever takes on a new value we can restore the old value, even if diverges for a long period between realizing the disagreeing computations. Second, we must be able to repeat this process and alternate between these incompatible outcomes as many times as we wish.
We tackle the first challenge by making sure that if then has the means to ‘rollback’ the axioms compatible with to any previous stage t at which α was visited. The idea here is that, by the remarks above, only axioms enumerated by descendants of α can change α’s approximation to C.5
That is, the approximation to C on the assumption that α is on the truepath at stages where . This is essentially the set yielded by over but we will offer a more precise definition latter and show that, at stages α is visited, the global approximation to C matches this approximation.
We enable this rollback by ensuring all and only the (relevant) axioms enumerated after stage t depend on for some value y in column . By enumerating y into C we recover the approximation to C (as seen from α) at stage t.
We tackle the second challenge by taking y in and out of C as needed to disagree with . By only enumerating y into C dependent on for some n, we can later remove y from C by enumerating into C. If changes back again we can reenumerate y dependent on and so on. Note that if we flip-flop infinitely often then and otherwise . At this point the broad outlines of the proof should be apparent, but the remainder of the paper is necessary to verify that the technical details can be filled in as I’ve suggested and when they are the construction behaves as expected.
Before moving on to the details there is one last big picture concern that must be addressed: ensuring that part 1 of Condition 1 can be satisfied with respect to the infinitary outcome of α. That is, ensuring that axioms enumerated by finitary outcomes don’t affect C if it extends .6
The infinitary outcome predicts the same content for column as the finitary outcomes leaving y out of C and column can’t keep incompatible with finitary outcomes that have flip-flopped sufficiently many times.
Of course, if all the finitary outcomes guessed y wasn’t in C there would be an easy solution. So we simply replicate that situation by adding a flag q into column which, unlike y, is always enumerated into C at finitary outcomes while also being canceled each time we visit the infinitary outcome. Essentially, q acts as a flag indicating whether α has an infinitary () or finitary () outcome, and we can simply insert q into the domain of for the appropriate children of α.
Global actions
To ensure the modules interact appropriately we specify two global rules which modify the axioms enumerated by the modules on the tree before they are enumerated into .
If enumerates axiom π then π is enumerated dependent on .
If wants to enumerate axiom π at stage s and implements an unactivated module then intercepts the enumeration of π, chooses large and enumerates π dependent on the partial function sending to 0 for each for which is defined. The resulting axiom is then passed down the tree for the next longest such β to modify or to be enumerated into if there is no such β.
The purpose served by these rules has already been discussed above. However, it is still worth noting that enumerating will cancel the effect of every axiom enumerated at or after stage s by any node and thus serve as the value y mentioned above. We now give the detailed actions of the various modules with the understanding that any axioms they enumerated will be modified in the obvious way to obey the above rules before being enumerated into .
The basic strategy
Suppose is assigned to β to handle and β is visited at stage s. If hasn’t yet been activated 7
Note that we will later observe no node is ever revisited after initialization so we need not consider such cases.
we search for an integer y such that if y is enumerated into it alters (incompatibly) the result of . If we don’t find such a y no action is taken and we describe the actions taken if it is found below. More formally we search for such that
When this occurs we say that is activated at stage s and select large to serve as our ‘flag’ by satisfying iff only cancels the enumeration of y finitely many times. Also pick8
In particular, we need so we may later select l with .
large with the intent of enumerating into column of C whenever we need to cancel an earlier decision to place y in C. If we enumerate into C at stage s we let . Otherwise , even if β isn’t executed at stage s. Note that we don’t increment the value of until is placed into , so functions as a kind of marker indicating the next element (if any) we will place in . Finally, let to indicate that if no further action is taken C will extend . This completes the action of at this stage.
Now suppose was activated at some prior stage, i.e., before s. Let be the last stage at which β was visited and let be such that . Say that stage s is eventful for just if (note that we regard the stage at which is activated as uneventful). In other words eventful stages are ones where we’ve changed our mind about what we want the value of to be.
If s is an eventful stage then we consider the following two cases. If we wish to make so we must cancel some prior enumeration of y into C that was made dependent on . We thus enumerate into C and (per the rule above) set . If then we wish to make so we enumerate y into C dependent on .
If s is not an eventful stage we don’t need to take any action to add or remove y from C. However, we need to ensure that our ‘flag’ q indicates that we took a finite outcome. To this end, enumerate9
We could have produced the same effect by enumerating q only at the first non-eventful stage following an eventful stage.
q into C dependent on , i.e., place q into C provided doesn’t enter . Note that at the next eventful stage t at which we cancel this enumeration of q by placing into .
Letting n be the number of eventful stages at or before stage s, we define the possible outcomes of β at stage s (i.e., the value of )
Note that outcomes of the form correspond to the guess that () if and () if .
If is activated at stage t and are as in Eq. (4.1) at stage t then let be and respectively where l is chosen large at the start of execution of at stage t so that . Since l is large, capture the effect of any axioms in over and respectively. We now define to extend or depending on whether this outcome (if true, i.e., ) places . Note the infinitary outcome doesn’t place y (or q) into C since every axiom enumerating y (or q) is eventually canceled. This definition will also ensure reflects the disposition of q and, for the finitary outcomes, enough elements in column to reflect how many times we’ve canceled a previous enumeration of y. Specifically, keeping in mind the remark above about the features of the outcome based on the value of we define
Note that if then . The outcome is differentiated by . The partial functions with and disagree on if , if and y if . Also note that incorporate the effects of any axioms enumerated before any is visited.
We are now in a position to define to be the partial function extending with domain by specifying its behavior on . As the only behavior not already captured in our definition of , is the effect of the infinitary outcome on column it is enough to define (where t is still the stage at which β was activated)
The basic strategy
Suppose is assigned to β handling . ensures that by ensuring that, for some y, either or . We now describe the action of the module which ensures this.
Suppose that β is visited at stage s. If this is the first time that β is visited then choose large (and in particular not in ). Whether or not this is the first time β is visited, if hasn’t previously acted check if . If so enumerate y into C, i.e., enumerate the axiom . We say acts at such a stage and once has acted it never acts again.
We define the outcomes of the module as follows.
For we define . For let t be the stage at which acts and let l be chosen large at stage t (in particular ). Let X be the set such that 10
Since this axiom (modified by global rules) is enumerated into at stage s it first appears in .
yields X over and define . Note that this ensures extends and .
Finally, define to be the partial function with domain extending and satisfying
Verification
We now verify that the construction above produces the desired set C. By Lemma 2.2 we have built an ω-REA set so all that remains is to show that and . We first demonstrate that this is a valid tree construction.
is well-defined.
Suppose, by way of induction, that is defined for and . If is of the form the either never acts and or at some stage acts and . If is of the form then either is never activated giving , has infinitely many eventful stages giving or has exactly m eventful stages giving . Thus, is well-defined and by induction f is well-defined. □
We note that no node is ever revisited after being initialized.
Supposeand for some,passes to the left of α then for no stagedo we have.
Suppose, for contradiction, is a ≺ minimal node for which the lemma fails as witnessed by stages . If passed to the left of α for some then the stages would witness the failure of the lemma at α contradicting the minimality of . Thus, α must visit some outcome n with at stages and visit some outcome at . To derive the contradiction it is now enough to note that only the outcome of the module is ever revisited after another outcome, and if outcome 1 is visited never again visits outcome 0. □
We now observe that the construction satisfies the stated condition.
We first verify part 1 of Condition 1. Suppose α is visited at stages and visited at with . Let γ be the longest common initial segment of and let be the (incompatible) children of γ with and . As neither module visits outcome 0 after visiting any other outcome neither a or b can be equal to 0. As the module would have only two outcomes, γ implements . Thus, by the comments immediately following Eq. (4.2) .
To verify part 2 of Condition 1, suppose that , and β visited before α. Let γ be the longest initial segment common to both . By the considerations above and the fact that all modules initially visit the 0 outcome, it follows that β extends . However, both modules choose for to have domain extending where l is chosen large after the last stage at which is ever visited. The desired claim now follows from the fact that . □
We now observe that this is enough to let us ignore axioms that are enumerated later by incompatible nodes.
Ifthen for allifenumerates the axiomafter stage s then.
This follows immediately from Lemma 5.2 and the application of rule (I). □
The strategy employed by the module depends on the fact that if and then, at some point, the approximation to C as seen by α also sees this computation, i.e., at some stage s with the set X yielded by over satisfies . To see how this might fail, imagine that at each stage s we both enumerate y into C dependent on while simultaneously enumerating into C. Ultimately, but the approximation to C given by looking at the effect of would always believe y is in C.
In our construction we were careful to ensure that if , then the axioms enumerated by α at or before stage s () are compatible with the guess () which α makes about C at that stage. These axioms may not yet enumerate all elements in but they don’t enumerate any element which or predicts isn’t in C.11
Note that in verifying this claim it is important to be able to see that the claim holds for α based only on the actual elements enumerated by so far and not merely that it’s true over .
To convince oneself of the truth of this claim, it might suffice to carefully walk through the operation of the modules. However, to formalize both the claim and its justification we introduce the following definition.
Using to refer to the value defined in Section 4.3 in the description of module we define
The idea is that captures the part of the guess makes about what C looks like which would be realized by .12
Note that we need to wait until stage until the axioms enumerated at stage s appear in .
Note that is always defined on since .
We can now formalize the idea that the outcome our construction guesses at any given stage is compatible with the results of the axioms enumerated so far.
Supposeandyieldsoverthen.
We will prove this lemma via induction but, for clarity, we separate out the largely technical inductive step.
Supposeandyieldsoverthen
In other words this lemma asserts that agrees with on the domain of both and .
(1) Note that agreement on comes for free, so it is enough to verify agrees with on the columns used by β. By Lemma 5.4 we may ignore any axioms enumerated by nodes incompatible with β visited after β and by part 2 of Condition 1 any axioms enumerated by incompatible nodes before β is visited can be ignored as they don’t have effect outside of . Axioms enumerated by nodes compatible with β other than β either don’t have effect outside or only affect columns after those reserved for β. It is thus enough to examine the construction and note that at stages where the axioms enumerated by β (on the assumption ) suffice to yield on the columns used by β. This is straightforward for module and for module is entailed by the discussions immediately preceding Eqs (4.2) and (4.3).
(2) This claim is trivial if as, in this case, so assume .
Since we assume , as above, Lemma 5.4 and part 2 of Condition 1 let us ignore any axioms not enumerated by β or a descendant. Note that if β implements there are only two possible outcomes and if β implements then for any . As no descendant of is allowed to enumerate elements into only axioms enumerated by β and nodes extending can affect on . Let t be first the stage some child of β besides is visited. Since outcome 0 is never revisited it is enough to show that plus any axioms enumerated by β by or at stage s yield over .
If β implements then at stage t we defined to be where X is the result of plus the axiom enumerated by β at stage t over and no further axioms are ever enumerated by β. If β implements then the discussion preceding Eq. (4.2) and an examination of the behavior of the module guarantees that the definition13
Note that if then at every stage is visited all axioms enumerated by β are canceled as is reflected in the definition of . If then it is enough to verify the claim for the first stage s at which is visited since β enumerates no further axioms until permanently abandoning the outcome corresponding to .
of takes account of and all the axioms enumerated up through stage s by β, i.e., is compatible with the set yielded by those axioms over . □
We prove this claim by (reverse) induction on β, i.e., with base case . First we note that if then the claim holds trivially since . Now, assume the claim holds for all with . Let be the child of β satisfying .
By part 2 of Lemma 5.7 we know that . If then by part 1 of Lemma 5.7 we also have . By Definition 5.5 this implies extends excepting only those locations in column where is undefined if β implements . However, no node other than β ever enumerates axioms dependent on these locations and β only enumerates elements inside V so we may proceed as if extended in determining the behavior of on . By the inductive assumption which is the set yielded by over . By the previous remark and thus . Putting this together with the above mentioned fact that lets us derive . □
Moreover, ifthen.
It is enough to show that if then since and if then and is (by construction) always compatible with .
We prove that by induction on α. Note that the claim is trivially true for so we assume the claim holds for α and that and demonstrate . We first show that . Let z be in column and find large enough that if then (by the note after Definition 5.5 suffices). First, suppose . By Lemma 2.2 let witness the fact that and let with and . By Definition 2.1. Thus, since and, by the inductive hypothesis, , we have and thus . By Lemma 5.6 so and by Definition 5.5 we can infer .
Conversely, suppose but . Again let with and apply Lemma 5.6 to infer . As there must be some axiom witnessing and, as , we can infer that for a contradiction. Thus, .
If α implements a module of the form we are done. Otherwise we prove the claim for column in a similar fashion, using the fact that . The argument that (where z is now in column ) implies goes through with only the slight modification of choosing s large enough that to ensure that .
Provided the same strategy works to show implies as well, since in this case . However, if we instead use the fact that the only values of z for which are enumerated via axioms that, by Eqs (4.2) and (4.3), don’t depend on any elements outside of , i.e., only if which is enough to complete the proof. □
C is not computable.
If C were computable then for some e. Now pick such that α implements a module working to satisfy , and let y be as in the description of the module. Now if then the truepath extends and . Otherwise the truepath extends and . Either way, the previous lemma ensures that . □
Suppose thatimplementsworking to satisfyand there are stagessuch that
isn’t activated at or before
then at the least stagewithis activated.
To prove the claim we must show there are satisfying Eq. (4.1) at stage s. We let , and let x be a location at which the computations disagree. We choose y to be the value where l is the least number greater than such that is defined.
By Lemma 5.6 and , where is the result of over and is the result of over . By Lemma 5.4, is also the result of over , since α isn’t visited in the interval . To verify the claim we need only show that if is the result of over then .
By Lemma 5.4 any axiom enumerated by after is incompatible with , no axiom enumerated by enumerates any element outside of , by assumption α isn’t activated and therefore enumerates no axioms before stage s and by global rule (II) any axiom enumerated by is enumerated dependent on . As y is chosen large after stage it follows that establishing the claim. □
Ifandthen V is computable.
By assumption there is some e such that and i such that . Let be a node implementing the module working to meet . By construction, if is ever activated with witnessing the satisfaction of Eq. (4.1) then with . By Lemma 5.8 contradicting the assumption that . Thus, we may assume that is never activated.
In this case we claim for some stage s such that and . By Lemmas 5.6 and 5.8 whenever we have . Thus, as and such a stage must always exist. If there were two such stages which disagreed on the value of then, by Lemma 5.10, would eventually be activated. Hence, by searching for the first stage s satisfying the above, we witness the computability of V. □
At this point, one might naturally wonder if this result could be improved by moving to ordinals past ω. One might conjecture there is some -REA degree C that forms a nontrivial minimal pair with . Disappointingly this conjecture turns out to be false. We sketch the proof below following the same approach as in Proposition 1.3 but now considering limit stages. The notation we use for computable ordinals is from [4]. Note that for the remainder of the paper we let and γ range over , i.e., notations for constructive ordinals.
We first remind the reader of the definition of an α-REA set. We differ from the definition in [1] only in that we define α-REA sets and not all α-REA operators.
(α-REA set).
An α-REA set is a set of the form , for a computable function f defined on , where is recursively defined as follows.
if λ a limit.
A -REA set for an ordinal is a α-REA set for any notation α with .
For any α-REA set,can (uniformly in α and an index for f) compute an index foras a c.e. set.
The essential idea here is that can search for indexes giving a computable definition for which it then verifies by using those indexes to generate computable indexes for the sets . Using the definition of as an α-REA set can then check that the version of built back up from the computable indexes for matches the initial guess at . As this procedure can check that satisfies every part of Definition 6.1.
We will show that we can uniformly computably generate an index for as a c.e. set from a guess at a computable definition for such that the sets only agree when our guess was accurate. In particular, we prove that there is a computable function such that
Note that this suffices to prove the claim since we can now find a c.e. index for simply by searching for a pair such that and . Applying the above equation in the other direction ensures us that there is a solution and since we can verify such a solution computably in this suffices to prove the claim.
We now construct q by using definition via effective transfinite recursion. We will define a computable function such that satisfies Eq. (6.1) if for all , satisfies Eq. (6.1) with respect to β. Then by application of the recursion theorem [3] we will recover a fixed point e such that is the desired function satisfying Eq. (6.1).
Before we construct , we observe that there is a total computable function h such that for all β if and then and for all , for some X. The existence of h follows immediately from the computability of f and definition of . Additionally, there is a computable function g such that if and then and if then . Such a g exists as it merely unwraps14
More formally, we define g as follows. If then . Let return the index such that . If define . Finally, if λ a limit and then let g return the index such that .
the effective join operations building up until it reaches . Furthermore, we can assume that is always empty unless .
If then returns a c.e. index for the empty set then Eq. (6.1) is obviously satisfied. If then first computes and and then before returning . Clearly, if and then, by the properties of g, and by the inductive assumption . By the properties of h we can conclude . Now, suppose, and . The definition of h ensures that has the form and the definition of g ensures that not only but also that has the form . Thus, it follows that and by the inductive assumption we can infer that . Hence, and by the definition of h it follows that .
If λ is a limit we define . Using g we can, define as computable functions of and . Finally, let be the index for and output . The verification is essentially the same as above. Supposing , if then and by the inductive assumption both are equal to which is enough to infer that . Going the other way, we note that if then we can infer agreement for each component and then use the inductive hypothesis plus the definition of λ-REA sets when λ a limit to show .
Finally, as mentioned above, is now defined to be where is a fixed point of I. □
Suppose that C is of non-computable α-REA degree then.
By the definition of α-REA sets . Thus, there is some least such that isn’t computable. If β is a successor then, just as in Proposition 1.3, . So assume β is a limit. By Lemma 6.2 we can uniformly find a c.e. code for each with . To determine if , we first ask if . If not . Otherwise ask for a c.e. code i for and report iff determines . Hence, in either case, and as we have . □
Footnotes
Acknowledgements
Partially supported by NSF EMSW21-RTG-0739007 and EMSW21-RTG-0838506.
References
1.
C.G.Jockusch and R.A.Shore, Pseudojump operators II: Transfinite iterations, hierarchies and minimal covers, The Journal of Symbolic Logic49 (1984), 1205–1236. doi:10.2307/2274273.
2.
S.C.Kleene, General recursive functions of natural numbers, Math. Ann.112(1) (1936), 727–742. doi:10.1007/BF01565439.
3.
S.C.Kleene, On notation for ordinal numbers, The Journal of Symbolic Logic3(4) (1938), 150–155. doi:10.2307/2267778.
J.R.Shoenfield, On degrees of unsolvability, Ann. of Math. (2)69 (1959), 644–653. doi:10.2307/1970028.
6.
R.I.Soare, Recursively Enumerable Sets and Degrees: A Study of Computable Functions and Computably Generated Sets, Perspectives in Mathematical Logic, Springer-Verlag, Berlin, 1987.