In 1982, Soare and Stob proved that if A is an r.e. set which isn’t computable then there is a set of the form which isn’t of r.e. Turing degree. If we define a properly -REA set to be an -REA set which isn’t Turing equivalent to any n-REA set this result shows that every properly 1-REA set can be extended to a properly 2-REA set. This result was extended by Cholak and Hinman in 1994. They proved that every 2-REA set can be extended to a properly 3-REA set. This leads naturally to the hypothesis that every properly n-REA set can be extended to a properly -REA set. Here we show this hypothesis is false and that there is a properly 3-REA set which can’t be extended to a properly 4-REA set. Moreover we show this set A can be .
In [1] Jockusch and Shore introduce the sets. A set is just an set, while an set is a set of the form where A is . Despite the fact that the sets are merely the result of iterating the operation of adding an set, many basic questions remain even when n is finite.
One natural property to investigate about sets is when they are properly .
A set B is properly if B is and B isn’t Turing equivalent to any set with .
It is evident that for all there are properly sets. But it’s obviously not the case that for every set A there is a properly set of the form , i.e., not every set can be extended to a properly set. For instance, the empty set is a set but can’t be extended to a properly set.
A natural hypothesis is that any properly set can be extended to a properly set. This represents the most optimistic possible hypothesis about when sets can be extended to properly sets.
If A is a properly set then there is a properly set (Turing equivalent to a set2
We add this caveat because, in the argument below, we adopt a slightly different form for sets that makes the argument more convenient.
) of the form . In such cases, we say A can be extended to a properly set.
Further evidence for this hypothesis comes in the form of a result by Soare and Stob [5] who demonstrate that for any set there is a set in but not of degree. This establishes that every properly set can be extended to a properly set. This result was extended to by Cholak and Hinman when they established the following result (recast using the above definitions) in [2].
If X is properlythen there is asetwhich is properly.
In other words any set which isn’t of degree can be extended to a set not of degree. However, despite the suggestive evidence we show that the above attractive hypothesis in fact fails by proving the following theorem.
There is a properlyset A which can’t be extended to a properlyset. The set A can also be taken to be.
Note that, if A isn’t properly then it is evident that no set of the form will be properly . Our strategy, roughly speaking, will be to build a set A such that enumeration into the first and second components of A (where the first component of A is the part of A and the second component is the part of Ain the first component) doesn’t result in further changes to . The construction takes the form of a finite injury argument, with the complexity arising from the difficulty of showing that the requirements eventually succeed. However, before we present the main construction, we first review some notation and define the sets in Section 2. Note that in this section we also introduce the idea that sets can be viewed as column sets (with the 0-th column empty) produced by an set of axioms.
Readers familiar with sets may wish to jump ahead to Section 3, where we describe the requirements that our construction will meet and delineate some basic conditions that our construction will satisfy.
Background
Notational conventions
We largely adopt the standard notation seen in [3] which we briefly review. The use of is denoted by , the e-th set in X by and we write () to indicate y enters (leaves) X at stage s. We let () denote a canonical bijection of () with ω and define , and standardly.3
That is, and .
We write () to indicate that two strings/partial functions/etc. are incompatible (compatible).
We also adopt some less common notational conventions and assumptions. We let the variables χ, ξ, η range over (binary partial functions with finite domain) with extension denoted by ≻. By identifying sets with their characteristic functions (so is really a ) we gain the ability for our approximations to a set A to take no position on whether . This turns out to be helpful in giving well-behaved stagewise approximations to sets.
With this notation in place, we briefly review sets and describe how we identify such sets with (non-trivial) column sets (and whose remaining columns are empty). The reader familiar with sets may wish to skip ahead to Section 3 after familiarizing themselves with the notion of an A supported approximation in Definition 2.6.
sets
In [1] Jockusch and Shore introduce the sets for any ordinal notation . In this paper, we will only be concerned with finite values of α so we adopt the following definition (equivalent up to 1-degree for finite α).
Given a computable function f, we define the operator (or where e is an index for f), via the following inductive definition (where we let if ).
Furthermore, C is an set just if for some computable function f and C is an set if it is an set. We define (written just as when n is understood) to be .
Note that, because of how we define an set Z will have for . We further note that we can describe the construction of with sets via the enumeration of ‘axioms’ defined as follows.
An axiom is a pair with , . An REA axiom is an axiom that further satisfies with and . Finally, an n-REA axiom is an REA axiom with .
We think of the axiom as an instruction to put y into a set Z provided . Thus, regarding y as coding an element of , an set of axioms defines (if compatible) a computable functional. An REA axiom is then an instruction to put z into provided (as this is equivalent to ).
We now argue that for we may identify operators (and hence sets) with sets of n-REA axioms and effectively translate between indices for sets of n-REA axioms and indices for operators.
If A is aset ofaxioms () then the operatordefined byis anoperator. Conversely, given anoperatorthere is asetsuch that. Furthermore, we can effectively translate betweenindices of sets ofaxioms and indices ofoperators.
We first prove that is an operator. Note that, for , is determined by and X so is well defined. Furthermore, the above equation explicitly defines from and l via a (uniformly) formula. Thus, by an application of the s-m-n theorem [4] there is a computable function f satisfying Definition 2.1.
Given we simply enumerate axioms into A when for . The uniformity claim is evident from the proof. □
In light of this result we adopt the following notation.
denotes a canonical enumeration of an set of axioms corresponding to the operator J. When is an set we write for (remember )
In various cases we’ll further specify which of the many potential enumerations of axioms we mean to specify with . For instance, we’ll explicitly define the enumeration of axioms for the sets we explicitly construct and rely on Lemma 2.3 to produce the corresponding set. We adopt the following definition to assist us in defining the axioms we enumerate in these construction.
The axiom depends on σ if . We say the axiom (element y) is enumerated dependent on δ to mean we enumerate into A.
We will call an axiom compatible (incompatible) with a partial function τ just if the partial function σ determining when the axiom applies is compatible (incompatible) with τ. We now argue that we can use an axiom set to approximate an set in well-behaved ways.
If A is a set of n-REA axioms we say that is A supported just if for all m, x with all of the following hold
If then .
If then .
If then
If χ is an supported approximation we say that χ is an s-supported4
Technically, being s-supported is relative to the choice of an enumeration of axioms but we will only use this notation when there is no ambiguity about the enumeration of the set .
approximation to .
Note that the notion of being s-supported is relative to a choice of a canonical enumeration of axioms for . Also, it’s worth observing the following point.
Given any set of axioms A and finite domain there is a unique A-supported χ with domain D.
It turns out that for any operator J we can effectively find an enumeration of axioms and a computable functional with , such that is always an supported approximation to and infinitely often . A proof of this claim can be found in the appendix to give the reader an idea how this can work. However, we don’t actually need the full strength of this result and will instead directly specify a stagewise enumeration of axioms and a approximation to the sets we are constructing. We will ensure this approximation has the following property (where A here is the set being constructed).
.
In fact, our approximation to A (which we define below) will turn out to satisfy the stronger condition that there are infinitely many stages such that . Note that, this implies that our approximation is a approximation to A.
Construction overview
We adopt the following notation for easier manipulation of sets defined in terms of columns pursuant to Definition 2.1.
Specifically, we will need that is large enough that if x is mentioned at or before stage s then , so that is large enough to see the next two elements in each column.
at the end of stage s.
Note that if both A and B are both then so is . Using these conventions we can now describe the broad outline of our proof of Theorem 1.4.
To establish the desired claim we’ll need to build a properly set A that can’t be extended to a properly set. In other words, for every the set must not be properly . So in addition to the set A we’ll build a sequence of sets Turing equivalent to the sets (note that by using rather than just we avoid the need for unnecessarily copying changes to A over to ). To verify these equivalences we’ll also need computable functionals so, in addition to the set A we’ll also build sets and functionals , Θ to satisfy all of the following requirements where denotes the e-th set.
:
:
We now observe that satisfying the above requirements is sufficient to prove the claimed theorem. However, the impatient reader may wish to jump ahead to the informal description of how is met in Section 3.1. Note that the general method there will be familiar to anyone familiar with the methods in [2,5] and broadly resembles the construction of properly n-sets (with some extra bookkeeping). Readers eager to jump ahead to the unique challenges and features of this construction should turn to Section 3.3 for an informal discussion or to the full construction in Section 4.
First we observe that our choice to avoid index profusion by using j as the index for both computations in is harmless.
Suppose A andsatisfy the requirementsandfor all i, j, e then A is properlybut can’t be extended to a properlyset.
If is satisfied for all i it follows that the set is Turing equivalent to . It only remains to demonstrate that A is properly .
Suppose, for a contradiction, that for some set . Then either , making A literally , or . In the first case would fail when j is an index for the identity function and e an index for the empty set. In the second case suppose that the Turing equivalence is witnessed by and and z is the least element in . Now let be the functional which asks if and if not computes and if so computes . Hence, if A is equivalent to some set it follows that some isn’t satisfied. □
We will build A or by enumerating axioms into A and respectively which, by the remarks above, uniquely determines the corresponding sets. We will define approximations , to the sets A, and adopt the convention that an attempt to enumerate x into A (or ) at stage s means enumerating x dependent on a large initial segment of the prior columns as defined by , .
We now formally specify our approximation and specify some properties it will be constructed to have.
is the unique s-supported approximation (i.e., -supported) with .
If x is enumerated into at stage s then and x is enumerated dependent on for (hence on prior columns of A up to height ).
At odd stages no axioms are enumerated into A and at most one axiom is enumerated into A at even stages.
To avoid the potential circularity induced by the interaction of Definition 3.1 and Property 1b we queue any request made to enumerate an element made during stage s until after is chosen at the end of the stage. Using and we can build an axiom satisfying Property 1b for an element queued for enumeration into which, in turn, lets us determine . Working inductively, this lets us identify an axiom for the element (if any) enumerated during stage s which satisfies both constraints.
We will also treat as the result of an enumeration of axioms and define an approximation that satisfies the following properties.
No axioms are enumerated into at even stages.
At any stage s there is at most one i and x such that an axiom enumerating some x into is enumerated and .
If an axiom enumerating x into is enumerated at stage s then x is enumerated dependent on .
denotes the unique finite partial function with domain that is -supported.
is the set built by applying the axioms to the set A.
Property 2c ensures that only axioms which agree with our current approximation to A are enumerated at stage s and are canceled by any change in . Note, these properties are only possible to meet, as we will now verify, because of Condition 1.
For all i there is an (uniformly specified) enumerationand an effective approximationsatisfying Property
2
.
We can assume we start with an enumeration of axioms such that iff and satisfies the usual rules for the enumeration of an A-set such as the enumeration of at most one element a stage etc. We now define in terms of the sets , .
If s is even we do nothing. So assume s is odd and let be the minimal value such that we can find , such that , and . If no such values can be found do nothing. If they are found enumerate the axiom into . By construction, we clearly satisfy properties 2a to 2d. It remains to show that Property 2e holds. By Condition 1 and Property 1c we can assume that infinitely often we have an odd stage s with , ensuring that eventually every element in gets an axiom enumerating it. □
We now give an overview of how each requirement operates.
Overview of
The basic approach to meeting is to use the fact that A is to change our minds about the behavior of some initial segment of A more times than is able to track. We now give an informal description of the process which we depict graphically in Fig. 1. In the figure stages at which a well-behaved back and forth computation exists are indicated by shaded/hatched regions. The region of A which is either hatched or shaded indicates the use of a computation of the shaded region of , which in turn extends the use of a computation of the shaded region of A. We describe such computations as well-behaved when (at stage s) an s-supported region of A (hatched and shaded) computes (via ) on (at least) an s-supported region (shaded region) which in turn computes (via ) . We leave cells blank if empty – unless they’ve just been canceled by an enumeration into a prior column, in which case we place a 0 in the cell. Finally, we circle locations which conflict with a commitment made by at a prior stage.
Meeting j,e.
We pick a value c at some stage which we hold out of . If we never see a stage and a well-behaved computation from A to and back then we are done. If we do see such a well-behaved computation then at stage we enumerate c into dependent on some large value staying out of .
If at some stage we again see a well-behaved back and forth computation (meaning disagrees with on the region shaded at stage ) we enumerate an element b into canceling c from . This restores the computation from A to seen at stage . Note that the only way we can again see a well-behaved back and forth computation (given we restrain enumeration into A) is if our approximation to restores the (used part of the) state it had at by enumerating an element into to cancel any changes.
Now suppose that at some stage we again see a well-behaved back and forth computation. We respond by enumerating an element into at stage canceling the enumeration made at stage into . This restores the computation from A to seen at stage . But now is unable to match this change as it can’t cancel the element enumerated into and, as we will prove in Section 3.1.1, the fact that A computed an s-supported approximation to at means this element was predicted by A to be out of at . This ensures that, provided we restrain modifications to A, we never again see a well-behaved computation from A to and back, guaranteeing that is satisfied.
We now formalize the argument made in this sketch and demonstrate that if the equivalence of A and is witnessed by then we will see infinitely many computations we’ve been calling well-behaved.
Positive change property
We now show that REA sets have the following positive change property. That is, the only way an approximation to an REA set can change is by enumerating a new element. We prove the results in this section for sets for arbitrary n, as this result will help us understand the strategy used to satisfy .
Suppose χ,are s,-supported approximations to anset Y withand. Ifbutthen. Moreover, there is a y andwithbut.
To establish the first claim suppose that the hypotheses of the lemma are satisfied. By Definition 2.6 there is some axiom with and . As if then as . But then by Definition 2.6 we would have , contrary to the assumptions of the lemma.
We now prove the second claim by induction. As is , the claim obviously holds for . Now suppose the claim holds for any and that the hypotheses of the lemma are satisfied for . Thus, . If there is some with and and , we are done. If not there must be a y with and . The result now follows by the inductive hypothesis applied to . □
We now give a slightly modified version of the above lemma that is specifically phrased in terms of undoing a previous change.
Note that WLOG we may assume by restricting to the domain of χ. With this assumption made, the pair χ, satisfy the hypotheses of Lemma 3.4 or , do. As whichever way we have . □
We now define a predicate which holds at x, s if it appears that computes enough of for to correctly compute the value of . Note that, in what follows, we will make use of an approximation to . However, somewhat surprisingly, all that matters about this approximation is that be s-supported and that, infinitely often, it’s domain includes any finite subset. As such, we can simply take to be the unique s-supported approximation such that even if this approximation isn’t even guaranteed to be (pointwise) infinitely often correct.
We define (written when j, e is clear from context) to hold just when there is some s-supported approximation ξ to satisfying
We note that if fails we can always wait for a stage at which our approximation witnesses this failure.
If,then for any x there are infinitely many stages at whichholds and is witnessed by, ξ where.
Suppose is as in the lemma. We first note that it is enough to show one such exists, since further witnesses may be generated by applying this result. Moreover, we may presume that since, as the approximation to A is infinitely often correct, we can simply wait for some later stage at which and then argue as below.
Since the reductions are total we can find ξ, χ such that is an supported approximation to satisfying and χ is an A supported approximation to A satisfying with . Now let be large enough that every axiom needed to ensure ξ, χ are , A supported has been enumerated by stage , , and the domain of ξ is contained in . Finally, choose so that and which guarantees . But now note that all the conjuncts in Definition 3.6 are satisfied so holds. □
Using this definition we can make precise the idea of an approximation changing its mind.
An increasing sequence of stages is k-flipflopping (for , ) at x denoted just if
is witnessed by some approximation to .
An element x is k-flipflopping at stage s (for , ), denoted just if there is an increasing sequence of stages such that .
When j, e are clear from context we will omit mentioning them.
We can now provide the framework for diagonalizing against .
Ifthenfails to hold.
Let and suppose, for a contradiction, that both and hold and are witnessed by the approximations to . By part 3 of Definition 3.8 and Definition 3.6 it follows that .
As we have by Lemma 3.5 we have and as we can apply Lemma 3.5 again to infer that . But s-supported approximations to an can’t disagree on column 0. Contradiction. □
With this in mind we can now reiterate the basic strategy we would use to meet if there were no other requirements. Choose some x and hold it out of until we observe a computation witnessing , i.e., a computation of an s-supported approximation ξ of which computes . This stage becomes in the lemma above and ξ becomes . Now enumerate x into dependent on a very large initial segment of and wait until we again see with a witness whose domain contains the domain of . This new stage becomes and this new witness becomes . Enumerate an element into depending on a large initial segment of canceling the enumeration of x and now wait until we again see with and a witness whose domain extends that of . Repeat the cancellation one last time via an enumeration into for a guaranteed win. At each point at which we wait on a computation we restrain any elements from being enumerated into any initial segment appearing in a computation we’ve used in this process. The lemma above ensures that this process ends in a victory.
Overview of
To meet we must construct sets and functionals that witness . As we control the construction of the sets we will simply settle on a particular way of coding into so we can share a single functional Θ computing from . As elements can both enter and leave (our approximation to) during the construction our coding mechanism must allow to change it’s mind about the value of .
To this end we use the x-th column of to encode whether or not x is in . To guess that we place into , to revoke that guess we place into , to guess x in we place into and so on. To avoid any need to memorize the particular coding convention we define the following notation.
When used without stage it indicates the least element of the form not yet enumerated into .
On the other hand, as we don’t control the set , the only way we can take full advantage of any change in is to build functionals so that it always tries to map to whenever but is reset whenever is reinitialized.
Let be the last stage with at which is reinitialized (injured). Then where t is the least stage satisfying , , , and . If there is no such t then
Note that Condition 1 ensures that is total as for every y there is a stage at which and . Also, observe that if then makes no commitments about x prior to stage s and thus any commitments made about x will be dependent on at least the initial elements of each column of A.
We build by enumerating axioms much like we do for A but, remember it is only the columnwise sum which we build to be not itself (this merely saves us the trouble of copying every enumeration into A over to ) Thus, the axioms enumerating elements into can depend not only on prior columns of but on prior columns of A as well. We omit the straightforward modifications to the definition of axiom to allow for this dependence. As with A we will simply indicate which elements we wish to enumerate into and rely on the following properties to uniquely define what axiom is enumerated and how our approximation to is affected.
is the unique partial function with such that is an s-supported approximation (i.e., -supported) (hence, , , ).
If x is enumerated into at stage s then x is enumerated dependent on and for (hence on prior columns of both A and up to height ).
Our construction will ensure that the following condition is satisfied.
For all s, and whenever both sides are defined. Moreover, is well-defined.
To this end, unlike the functional , we don’t reset the set of axioms enumerated into when the module implementing is reinitialized since isn’t reinitialized.
Requirement interaction
Note that we can regard as (equivalent to) a set so the same considerations about an set avoiding equivalence with an from Section 3.1 apply but now it’s our job to ensure equivalence. Obviously, if we could leave empty (or even computable) then we could trivially meet simply by enumerating into whenever we see z enter (as we could wait until had settled) and simply copying , into and respectively. However, meeting requirements of the form forces us to make (non-computable) enumerations into all three columns of A.
Specifically, an opponent building could try to duplicate the kind of argument we gave in Section 3.1. If such an opponent could arrange for the approximation to to flip-flop on some value z 4 times (waiting for new , Θ computations each time) then we would have no way to change to meet . This situation is loosely depicted in Fig. 2 where the shaded region is meant to represent the region below (and thus use and domain of Θ and ) while the hatched region in stage represents the use of the computation which disagrees with .
Piggybacking off j,e.
For instance, our opponent might start by reserving some value z to be kept out of . By waiting until we’ve committed to the behavior of our functionals on the appropriate initial segments our opponent could force a change to by enumerating z into with some large use and wait until some stage at which our functionals again witness (enough of) the equivalence . The proof of Theorem 1.3 from [2] shows that our opponent can ensure that sometimes we’re forced to enumerate some y into (to cancel a previous enumeration into ) in response to some requirement enumerating c into . That is, we can’t avoid getting to stage as depicted in Fig. 2.
Safety via agreement
If is of higher priority than we need to be able to meet in a way that doesn’t allow an opponent to force an injury to . Our strategy will be to modify the way (the module responsible for meeting) operates to ensure that when enumerates b into we aren’t forced to enumerate any element into , i.e., we avoid ever reaching the stage labeled in Fig. 2. If we can arrange this, it removes our opponents 1 column advantage on us which will prevent from injuring (the final enumeration of a into will thus keep and in lock step).
The key idea here is that b’s entry into can only force us to enumerate an element into if there is some (small) value y with but . In other words we will wait to enumerate b until the second (and first) column of are the same as they were immediately before c was enumerated.
As the enumeration of c into at stage will generally force a change in and since we can’t control we can’t ensure this condition is met for any particular value c. Instead, we make multiple attempts to meet with the first attempt enumerating into , the second attempt and so on and argue that for some we either meet without canceling c or that we eventually see the agreement needed to allow safe enumeration of b into .
Specifically, at stage we initialize (the module for) choosing large and setting (in the full construction will be partitioned between the various requirements to avoid collision). At stages we observe an active stage for and, if we haven’t yet found agreement (i.e. some which we can now cancel without changing the first two columns of any set ), we respond at stage by enumerating (only) into .
There are two critical aspects of this strategy. First, we ensure that is small relative to the stage at which is first enumerated so that each time we enumerate some we are extending the use of . Hence, commitments made about after stage are canceled when we enumerate any into . Second, the fact that we choose large means that if then no enumeration of will cancel z (and thus no reason to change how codes z’s membership in ). Note that it will also be the case that each time we enumerate some we will remove6
Remember, that we’ve used the fact that we will ensure infinitely often to allow us to set the ‘use’ of a computation placing at stage s to .
any z enumerated into since stage . Thus, the only real constraint prior commitments impose on us while trying to produce the desired agreement is that we must remove from if present whenever we enumerate any into .
The main difficulty in the construction will be to argue that we can always arrange our enumerations into during the intervals so that we eventually find some we can cancel without changing the first two columns of any . Stated in terms of the following definition we need to show that we can find , k such that . That is, there are active stages for (or there are only finitely many such stages) such that canceling by enumerating at stage7
Note that in full construction we assume that no elements enter any at stages so we need not worry about changes between and .
(which requires us to return all to a state compatible with that at ) won’t require changes in the first two columns of (the third column is returned to it’s earlier state for free by the enumeration of ).
We define
We say that s, tagree just when .
For future use we also adopt the following terminology (reflecting the fact that if t is accessible at stage s then there is some possible enumeration of elements into the sets that would allow some later stage to satisfy ).
A stage t is accessible at a stage just if for all i
A stage is (i-canceled) canceled just if it isn’t (i-accessible) accessible.
We also adopt the definition below. Note that active stages are the stages at which takes action in response to seeing a longer back and forth computation on it’s own accord rather than merely responding to some enumeration into .
A stage at which enumerates an element into or is a () active stage. A stage is called a () preactive stage just if is an active stage.
Simplified agreement
Let’s consider how (the module for) might enact this strategy with respect to a single requirement assuming only a single value z enters or leaves . On this assumption, we’ll describe a winning strategy for that enumerates at most two elements , into . This strategy is visualized in Figs 3 and 4. Note that, while the figures depict and as being on the same level but in reality is smaller than which is why we shade a larger region of (where the shaded region indicates the region below at the given stage).
Satisfying respecting on z.
If z doesn’t enter in the interval when we enumerate we get for free since there was never any need to cancel any element in (this case isn’t depicted).
Alternate behavior after stage .
In Fig. 3 we see that z enters by stage forcing us to cancel at stage . Note that when z first enters we become free to code that entry into since the enumeration changes on the use of . However, in the figure z isn’t enumerated into during . We’ve circled the value which blocks agreement at stage with the earlier stage . But now observe that at stage agreement is achieved for free since we had no need to cancel any elements at stage (with playing the role of c). As we will see later, even if we’d had other intervening stages as long as they didn’t enumerate any elements into small at stage we could cancel their contributions. Note that when we enumerate into it automatically removes from as this was enumerated during the interval (remember is not ).
In Fig. 4 we depict the case where z is enumerated into at some stage . At stage (we can’t wait until ) we are faced with a choice. We could simply enumerate into again but then the value we enumerated into at stage would prevent us from achieving agreement between stages and . So instead we choose to cancel the value enumerated into and restore the state of at stage producing agreement.
So far our examples have always shown z entering before the enumeration of as this is the most challenging case to achieve agreement. However, it’s useful to consider the case to illustrate two important points. First, to demonstrate why it’s only agreement in the first two columns of which matters not agreement about and why later enumeration into doesn’t threaten agreement once it’s been achieved. This situation is depicted in Fig. 5.
Satisfying , when removes z from .
In this scenario z doesn’t enter before, at , we enumerate into . As such, we don’t enumerate before either so it need not be canceled at stage . Hence, at stage we already have agreement with stage , i.e., . However, we may have to wait to see a expansionary stage and during that time we may see z enter . But, note that, once we’ve achieved agreement we can always respond to such an entry by enumerating (labeled above as ) into without jeopardizing that agreement. Thus, at stage when we finally see a expansionary stage we have .
Now, remember, that it’s not actually that we’ve committed to building as a set but (the columwise sum). Hence, the enumeration of into doesn’t just cancel but also (in Fig. 4 we glossed over need to reenumerate this element when was enumerated). Thus, at we comply with the commitments made for at . Of course, z could still decide to finally enter at this point but, since z wasn’t in at stage , we are no longer committed to keeping out of allowing us to preserve the computation required by . Finally, if we enumerate a, we again rely on the fact that it’s that’s to allow a to cancel both and returning both sides to stages compatible with those they had at stage . Note that if, instead, z had been out of at stage and then entered after the enumeration of a we could respond by enumerating just as we did when z entered after the enumeration of but before a.
General agreement
In Section 3.5 we demonstrated how to meet without injuring a single requirement on the assumption that only a single value z ever enters or leaves . However, in the general case we must meet without injuring any of the finitely many higher priority requirements , , , …. We must also accommodate arbitrarily many elements entering and leaving the sets .
Multiple elements entering some
First we explain the relatively easy task of dealing with multiple elements entering and leaving the sets . By the discussion in Section 3.4 the enumeration of cancels any commitments we’ve made about after stage . Hence, if then Definition 3.11 means that at we’ve yet to make any commitment about z (i.e. about the value of on ). This leaves us with finitely many values we must be concerned with entering or leaving any when trying to achieve agreement. Note that if we ever see enter after stage this cancels any commitments we’ve made regarding allowing us to freely code changes in by enumerating elements into . Morally speaking, this means it’s only the least value of z entering in the interval which matters so we need only tweak the strategy above to deal with multiple values entering/leaving some .
More specifically, we eventually find such that the least which is in some also is in or eventually all aren’t in . In the later case we have as we are in the same situation depicted in Fig. 3. In the former case, as in Fig. 4, we ensure by making enumerations into when we see a new least enter that cancels all changes since the last stage with and making whatever corrections needed to code the state of by enumeration into . Note that no problem is introduced if, in response to the entry of into at stage we make an enumeration into to cancel all changes between and s. Such enumerations may prevent ever achieving agreement with some (as we can never remove an element from ) but that’s not a problem since the canceled stages are ones in which no enters .
Multiple requirements
This leaves us with the harder problem of dealing with multiple requirements , , …, at the same time.
Unlike the case with multiple values entering a single set, here entry into doesn’t cancel any commitments made about , . Thus, when we see z enter we must immediately decide how to code this change in (by enumerating into or cancelling a removal from it by enumerating into ) without yet knowing what elements may later enter some . We now describe how we handle this problem under the simplifying assumption that there is only a single value z which may enter any set and 8
If then z won’t leave as a result of any enumeration we make in trying to meet ensuring that coding the status of z isn’t in tension with our attempt to meet .
where . As there is only a single value of z in play we will only ever need to make use of a single location to code whether or not (i.e. if we see z leave we always remove from ) and WLOG we can assume that value is independent of i and just write .
We formulate the problem slightly more generally as trying to meet while respecting the requirements , , …, (i.e., assuming that agreement is automatic for i not in ) and then argue that we can reduce this to the problem of respecting n requirements. Since we’ve assumed that at each stage where we enumerate into this has the effect of removing z from . To ensure that the sets reflect this we enumerate into if where t is the stage at which entered in the interval . Thus, at each stage z isn’t in any of the sets nor are the elements . Note that, in the case where for all we don’t enumerate any elements into at stage meaning that we automatically have and, by the remarks at the end of Section 3.5, once established we can maintain this agreement until stage as we only need to enumerate elements into the third column of the sets to respect the requirements , , …, .
What we must do is describe a strategy for reacting to the enumeration of z into during the interval (the interval between and entering ) that ensures we will eventually produce agreement. The key factor that determines how we act to try and produce agreement during the interval is which of the sets we see z enter first. To this end, define so that is the m-th interval on which z first enters .
Our argument is essentially a priority argument in which we give highest priority to producing agreement between intervals in which the first set z enters is . We give second highest priority to producing agreement between intervals in which z first enters and so on. Specifically, during the interval we will attempt to produce agreement with the stages ignoring any intervening intervals in which z first entered some other set in our list. However, as when we service a higher priority requirement in a finite injury argument, when we first see z enter we abandon our attempts to produce agreement on intervals where z first enters some other set. Thus, during the interval we will only attempt to produce agreement with the stages where is the least value such that there is no k with . Similarly, in the interval we only try to produce agreement with the stages which have occurred since the last interval in which z first entered or and so on. Of course, if we already have agreement with some earlier stage (e.g. because z didn’t enter any of our sets in the previous interval) we simply maintain it regardless of which set is entered first.
Thus, if s is the first stage in at which we see z enter some with there is a (potentially empty) list of earlier stages9
For instance, if z first enters and then , and if z first enters and then , .
which we will try to produce agreement with. If this list is non-empty then we immediately10
Stage since we interleave stages at which enumeration into A and sets in A are seen.
and enumerate into to cancel all elements enumerated into at intervening stages. This enumeration also cancels the element enumerated into at stage t and thus returns into .
This has the effect of ensuring that . Note that if we are only trying to respect a single requirement this strategy ensures we always achieve agreement. Either z doesn’t enter during the interval in which case we achieve the free win mentioned above or during the interval then the list of prior stages we are attempting to agree with is non-empty ensuring that .
Now we notice that the argument we just gave depends only on having a sequence of intervals with such that at every stage we have , , all elements enumerated into between and are larger and that, if z enters in for some then enumerating into restores to the state it had at stage . Finally, we observe that if is such that , where, as above, z doesn’t first enter any during any interval between and and is the stage at which z enters in the interval ending at stage satisfies these properties. That is, is the sequence of stages that we try to achieve agreement with when we see z first enter during the interval ending with . Thus, when see z first enter in an interval we can then run the same strategy on the indexes in on these reduced intervals.
Agreement respecting and .
Alternative agreements respecting and .
The notation gets a bit heavy in that last discussion so to make this concrete consider Fig. 6 where we give an example of trying to produce agreement while respecting the two requirements and . In the figure we’ve only shown the final stage of intervals and we’ve boxed (including the double box) the stages which correspond to intervals in which z first enters . Note that, on the intervals ending at stage , where z first enters we have and the behavior of looks just like the strategy we would follow if we were dealing with only the requirement . However, when we hit the interval ending at in which z first enters this attempt is injured so in the interval ending , starts afresh and doesn’t try to create agreement with stage .
Furthermore, note that at the boxed stages (the last stages of intervals at which z first enters ) agreement works as if the unboxed stages don’t exist. Thus, since we have just as in the case where we dealt with only a single requirement we eventually achieve agreement on that index as well ensuring . Note that in Fig. 7 we give two alternate ways that the interval ending at stage could have played out. On the left we see that if we had a long enough consecutive sequence of intervals in which z first entered that too would have produced agreement while, on the right, we see how we would have achieved agreement between the double boxed stages had z entered during the interval after z entered .
Finally, one might wonder how, even though a smaller value of z entering subsumes larger values entering the same set how we can handle the case where we first see the larger values enter when we don’t yet know if the smaller value will later enter. We can handle this the same way we do with multiple sets where seeing 0 enter first can injure seeing 1 first enter and so forth. Though, by the discussion above, we need not worry about the case where the larger number enters during an interval after the smaller number.
Now that we’ve outlined the general approach we give the full construction. The complexity involved in this construction largely reflects the difficulty involved in doing accurate bookkeeping for the approach described in this section in the case where we must deal both with achieving agreement with respect to multiple values of i and multiple elements entering and leaving the associated sets.
Full construction
General framework
The construction takes the form of a finite injury argument with the module tasked with meeting having priority and the module tasked with meeting having priority . Modules of the form merely define as specified in Definition 3.11 and thus have no direct effect on any set or module. In contrast, any time the module acts all lower priority modules are reinitialized.
At any even stage s at most one requirement of the form with priority at most acts while (at most one per stage) enumerations into occur only at odd stages. In response to an enumeration into we give each requirement (in decreasing order of priority) the chance to act and claim the enumeration (injuring lower priority requirements) and enumerate elements into in response. We apply the following rule for unclaimed enumerations.
If an axiom enumerates z into at stage s but z goes unclaimed then we enumerate into .
Module
We break up the description of the module into two parts. First, we describe the behavior of the module at even stages when it may act of it’s own volition to modify A and possibly the sets . Then, later, we describe action of the module at odd stages in response to an enumeration into a set .
Even stages
The module tasked with meeting has four 4 states, where ↑ indicates has yet to execute after (re)initialization and the later numbers (roughly) indicate the number of times we’ve changed our mind about whether . We denote the state of the module at the end of stage s by and assume that the state remains the same at stage unless otherwise noted. Note that, in state 1 we’ve enumerated at least one potential value for for c into but we may not yet have enumerated the ultimate value c takes into . If is injured at stage s we set .
We describe the behavior at stage s where we may assume that the following all hold.
s is even, and no higher priority requirement has chosen to act (injuring ) at stage s, i.e., we execute this module at stage s.
is the first even stage after the most recent reinitialization of .
The element is defined to be if .
is enumerated into at stage and m is the smallest value for which is undefined and less than s (thus is the next element waiting to be enumerated into ).
are values chosen large at stage satisfying and for any i and . Note that this implies .
(Even Stages of ).
Case:
We act by choosing where v is chosen large and setting .
Case:
If holds then we act by enumerating into , executing Procedure 2 and setting
Case:
We execute the following steps.
If fails to hold end the stage without acting. Otherwise the module acts by executing the subsequent steps.
If there is with perform the following steps and end the stage.
Choose large.
Set , , , .
Enumerate b into and set
If there is no such k we instead enumerate into and execute Procedure 2
Case:
If the module acts by enumerating a into and setting , .
Case:
Once in state 3 the module never acts again.
We now specify the procedure we referenced above when we enumerated . As we want to maintain Condition 2 (correctness of our functionals) at all active stages we must return , by potentially enumerating an element into , to a state compatible with . However, what, if any, element must be enumerated into at is determined by how we choose to respond to enumerations into so we hand that task of keeping track of that value to the machinery which responds to those enumerations. Specifically, for each we define (relative to ) a marker with initial value . At active stages we’ll just trust that we’ve placed this marker on the right value and do the following.
(Resetting ).
Execute the following steps when called:
For every enumerate into if and update to ↑.
If or then at the end of the stage enumerate into if we would otherwise have .
Note that unless no elements have ever been enumerated into so we need take no action to maintain agreement between and .
Odd stages
It’s now our task to ensure that there are two preactive stages t, that agree in the sense . Since we may injure lower priority modules we have no obligation to undo enumerations into at active stages as we do with . Thus, we can simply leave enumerations into to lower priority modules (or leave them unclaimed) without concern they will block us from achieving the desired agreement. On the other hand, if then the use of for any element coding the status of z is large enough that we can redefine it every time some is enumerated into by . Finally, once enters state 2 we are too far along in the process for changes in to migrate all the way to the first column in time to cause a problem. We only claim those finitely many enumerations which don’t fall into these easy cases.
If , then claims z just if and .
Our active management in these cases is complicated by the fact that we may only modify the elements in coding the status of immediately in response to the enumeration of z. Our basic approach to deal with this problem is to use the order in which elements are enumerated into the sets during an interval to determine our response. However, our approach is only easily described in a recursive fashion. To that end we abstract away from the particular rule we will use to respond to enumeration and define the notion of a strategy. A strategy is a procedure with persistent state (i.e., a coroutine) that tells us how best to respond to an enumeration of z into the set given some finite set S of stages we are trying to produce agreement with (or force future agreement).
We now define the notion of a procedure whose task is to tell us how to respond to an enumeration of z into at stage s.
A strategy is a computable function (subroutine) with persistent state which enumerates a finite set of elements for entry into and recommends an update to . The persistent state of consists of a number of variables which updates and whose values persist across calls. In addition to the explicitly given arguments and persistent state we also assume that has access to a complete history of enumerations/recommendations made11
Including enumerations/updates that some calling strategy has already committed to recommending but haven’t yet been made.
prior to it’s execution.
We will describe the behavior of a strategy by giving a procedure by which it updates it’s persistent internal variables (initially set to ↑) and leave it to the pedantic reader to translate such a description into a fully formal object. We also need terminology for the stage (if any) in the intervals at which control is first passed to a particular strategy as follow.
A stage s is an initial enumeration for (relative to ) if is executed at stage s in response to the enumeration of z into and if there is some k such that and was not executed during the interval . In such cases we also say that the initial enumeration for during the interval was into .
Our goal is to prove that, given any value of we can effectively produce a strategy which, if followed whenever any enters some , guarantees that after some finite number of preactive stages we’ll succeed in producing agreement.
Specifically, we’ll show that for any with compact support there is a strategy such that is capable of producing agreement while respecting the requirements for provided that the only elements z entering or leaving satisfy . We will then argue that if for every with (relative to the counting measure) is guaranteed to win then so is . As when h is the zero function, there are no values of i, z with , clearly satisfies the above assumption. The desired result will follow by induction on .
First, however, we describe the procedure . In this description, we style variables which persist across calls in Fraktur, e.g., , and adopt the computer science convention that we specify temporary values via ‘let’ while we update a variable in the strategy’s internal state with ‘set’.
The strategy for with is defined to be the strategy with the following persistent internal variables (all of which are initialized to ↑) which executes Procedure 3 when called as12
That is, follows the steps in Procedure 3 with , , , .
.
, which records the greatest non-canceled (i.e. accessible) preactive stage at which initial enumeration for was made into . Note that we may assume that actually records the value of k rather than behind the seems and uses k to return so that we may assign to even when that stage hasn’t yet happened.
holds the current state of the substrategy tasked with producing agreement in response to initial enumerations made into .
, identifies the value, if any, needed to cancel the values in coding the status of (the only value is directly responsible for) at the next active stage. will recommend that be set to the least of and the recommendations of any sub-strategies.
In what follows we drop the superscript h from persistent variables when clear from context.
Suppose that,
.
m is largest with .
,
then behaves as follows when executed at stage s. Note that always returns the current value of when it ceases execution as it’s recommendation for .
Enumerate into and exit any strategy (even parent strategies calling this one). There is no need to recommend an update to since we are guaranteed agreement.
Projecting on the (valid) assumption that all recommendations for enumeration committed to by strategies executing before this one during stage s will be made.
set to be undefined and execute the following steps:
Set and for all r, set and to ↑.
Let n be such that and set equal to (yes, in the future). For all , if , set .
If is undefined set with all persistent variables initialized to ↑ where
then do the following. If mark for enumeration into and set to a large value returning that as our recommendation for . If then execute and let our recommendation for be whatever was returned by . In either case, cease all further execution and return to caller.
Only if both and were defined at the start of execution will we pass beyond this point.
Enumerate the least satisfying into . This has the effect of returning to the state it was in at stage .
Note that, if we’ve previously enumerated a at some stage it is enough to enumerate so we need not worry about running out of values but for simplicity we’ll assume14
An assumption that will be vindicated by the calculation of an explicit bound on the number of preactive stages before agreement and thus on the total number of strategy executions which in turn gives us an explicit bound on the number of values we may need to enumerate between and .
that we always have .
place into .
This has the effect of canceling (as if we were the active stage ) the elements in which code the membership of those . Note that this enumeration may be canceled by a sub-strategy at this very stage.
set to as at the next active stage we must be prepared to cancel the enumerations into we restored by the enumeration of q.
Execute (updating the internal state) and pass on the set of elements to be enumerated unmodified. Let b be the recommendation for returned by the sub-strategy just executed.
Let be the set of axioms projected to be active at the end of stage s such that has the form but . If V is empty then set to ↑. Otherwise, let t be the least stage at which one these axioms is enumerated and the least preactive stage after t. If there is no such , i.e., , then leave unchanged. Otherwise, set to .
Check if, absent this step we are on track to have . If not enumerate into and if is undefined set to be large.
Return to caller with recommendation for equal to the minimum of b and (always passing through any requests for enumeration).
We can now give the rule for responding to a claimed enumeration using the following specification
We presume that we initialize a strategy of the form at stage and adopt the following rule.
If , and claims z then execute and follow it’s recommendations.
Note that, whenever we say things like “execute ” there is an ambiguity between the procedure, which might be instantiated multiple times, and the particular instance. However, we’ll see in part 4 of Lemma 5.3 that in any context each strategy will only ever be instantiated once so there is no risk of confusion.
Verification
We now demonstrate that the construction given above satisfies the requirements. In what follows we will frequently prove results about the strategy by either via induction or descent on strategies so we remind the reader that relation between strategies which holds whenever calls a strategy is a well-founded relation. To see this note that under the counting measure on ω, the integral is a functional from to ω and for each r we have .
To facilitate these arguments we’ve defined so that when we initially execute the configuration sees (i.e., ) resembles that seen by (and indeed present at stage ). However, to make use of this we need yet more notation.
If the strategy is executed at stage s then let denote the state of at the start of execution of (including any enumerations scheduled by strategies prior to this point) and let denote the state of at the end of execution of . When instantiates , we also denote the values and by and respectively.
Note that we’ll continue to use notation like which is defined relative to a requirement without making the dependence on j, e explicit when it is obvious from context which requirement is relevant.
Correct computations
Our main goal in this section is to prove that Condition 2 holds. However, we first must prove that . But we need a number of utility results first, some of which depend on the very fact to be proved. We therefore present the lemma below but hold off on a proof until we can gather up all the inductive hypotheses needed.
Suppose thatisn’t initialized betweenandandthen
Ifandwe have.
Ifis the greatest active stage less than s andis the result of enumeratinginto,,then.
We now prove our utility results, some of which assume that Lemma 5.2 holds at earlier stages.
Suppose thatinstantiatesand receives an initial enumeration of z intoat stage(note thatis possibility infinite) then
If x is enumerated intoat stagethenis executed to handle this enumeration iff.
At no stage indoes any strategy other thanenumerate elements into.
At no stage indoes any strategy not called fromenumerate elements into.
No other strategy implementingexecutes during.
Ifexecutes stage Step
2e
enumerating q withintothen nohas been enumerated since stage.
If we further assume that Lemma
5.2
holds forandthen we may also conclude.
For all,andifthen.
For all, x ifthen. In other words, initial enumerations to strategies start with a blank slate.
We prove these claims by descent. For claims 1, 2, 3 and 4 we observe they clearly hold for and we now prove that these claims also hold for the strategies called from .
To see that 1 holds note that the only time doesn’t pass on z is when and that by eq. (3) this is the only element which isn’t below . To see that 2 (and, thus, 3) holds note that only Step 5 ever enumerates elements and then only if . is passed any element as the only time x received by and only enumerates into before executing for the first time.
To see that 5 holds it is enough to observe that if the first time after reinitialization that runs is (with possibly infinite) then neither nor any strategy called from it will enumerate elements below . Then observe that if we ever run with we reinitialize so that if we had run some strategy that wasn’t called by but enumerated a value below we would have reinitialized after contradicting the choice of q. The conclusion follows by observing that, after stage , the first time is run it enumerates q before any sub-strategy it calls enumerates anything.
To prove 6 note that the base case holds by the assumption of Lemma 5.2 and we can ignore any stages at which no enumeration into is claimed by . If is executed at s then so direct enumeration can’t cause disagreement. This leaves only enumeration into as a threat. However, when this happens Step 2e restores the state as of and by the inductive assumption (with replacing s and replacing ) we can conclude that if no are in then . Conversely, if there is such an then Step 2f enumerates into which, by 5 ensures that by the assumption of Lemma 5.2.
With item 6 established we can now proceed to prove 7 in exactly the same manner. Note that 7 clearly holds if by our assumption that Lemma 5.2 holds at . For the inductive case we need merely replace the assumption that no are in with the assumption that is executing before the initial enumeration for noting that by 1 if executes before the initial enumeration for in then . □
We now return and provide the promised proof.
Suppose thatisn’t initialized betweenandandthen
Ifandwe have.
Ifis the greatest active stage less than s andis the result of enumeratinginto,,then.
We first prove 2 on the assumption that 1 holds at each .
By Lemma 5.3 it is enough to argue that if then (and thus ) cancels any changes made by , to . After all, item 7 ensures that the claim holds true at all stages prior to such an enumeration, item 7 ensures that it is true when receives it’s initial enumeration, stages at which enumeration occurs into some don’t alter or . But the combination of Steps 4, 5 and out assumption that 1 holds at all ensure that is small enough to cancel any active axioms causing to disagree with or Step 2d when it is an initial enumeration and is undefined.
We now note that 2 is trivial if and otherwise follows by induction on k by application of 2 and the fact that Procedure 1 executes Procedure 2 when it enumerates . □
We are now in a position to prove Condition 2 holds. We break the proof up into two lemmas.
For all s, i,is compatible with. Moreover, ifthen.
The moreover claim is trivial since, if , then we’ve taken no action regarding x at or before stage s. We let i be arbitrary and proceed by induction to prove the main claim. Trivially, the claim holds if so we assume that the claim holds for all stages prior to s and argue the holds at s. If no enumeration happens at s into either A or the result is immediate. So we consider the following (disjoint) cases.
Case:
This case can be broken into two subcases.
Casexis claimed by some:
In this case, there is some executing at s such that . Step 5 plus the fact that no elements are enumerated into either or after Step 5 during stage s establish the claim.
Casexis unclaimed:
In this case, the result follows immediately by Rule 4.1.
Case:
Suppose is responsible for the numeration of and consider the following subcases.
Case:
In this case, as any enumeration below would have injured . Similarly, . But as we only enumerate elements into when it appears that the lemma would fail no such elements are ever enumerated at or after so the claim holds by virtue of the inductive hypothesis applied at stage .
Case:
Note that if then the claim follows immediately via the action of Step 2. So assume . Since x is enumerated into after stage , x is (by induction) enumerated dependent on . Thus, and the desired result follows by Lemma 5.2.
Case:
Suppose is responsible for the numeration of b. Step 2 ensures that there is some k with such that . But the enumeration of b (chosen large at stage ) cancels all enumerations into after stage and as this ensures that . As the enumeration of b also cancels any enumeration of x into after stage the result follows from the application of the inductive hypothesis to stage .
Case:
Suppose is responsible for the numeration of a. The enumeration of a cancels all enumerations into since the stage t at which b was enumerated as well as any enumeration of x into after stage . As no enumerations were made into since stage the state at stage is restored and the claim follows from the inductive hypothesis applied at stage .
□
Now to prove the corresponding claim for .
For all s, i,andis well-defined.
Note that, here really refers to whatever version of the functional is left uninjured at the end of stage s since we will reinitialize each finitely many times.
By Definition 3.11 it is evident that is well-defined. To prove the remainder of the claim it is enough to show that if and is not injured during the interval then
The claim is trivial if so we assume the claim holds for all with and prove it also holds at s. This is evident if no axioms placing an element into A or are enumerated at stage s. So, suppose, for contradiction, that some element is enumerated at stage s and is not injured during the interval but that eq. (4) fails. We consider the following cases.
Caseand:
For the claim to fail we must have z in (our approximation to) at stages t and but not . Thus, we must have some in but not rendering eq. (4a) false.
Case:
Suppose that enumerates q. Note that if and takes any action then is injured giving us the desired conclusion trivially. Thus, we can assume and consider the following subcases.
Case:
We must have or makes eq. (4a) false where is the least active stage greater than t. If then that disagreement would persist until stage s making eq. (4a) false. But Lemma 5.2 lets us conclude that so .
Case:
This follows from the inductive assumption plus Lemma 5.2 which ensures that if then eq. (4b) holds. If then the enumeration of some or q itself renders eq. (4a) false.
□
We can now prove the desired proposition.
Condition
2
is satisfied, i.e., Θ andare well-defined and correct at every stage.
In this section we seek to show that only acts finitely many times. To prove this we need to show that our strategies eventually guarantee we find agreement between stages. But the strategy doesn’t execute on consecutive intervals . It may, instead, skip a number of active stages during which executes some other sub-strategy only to return to much later so we need some way to talk about intervals which behave as if we had run on consecutive intervals.
To this end, we make the following definitions (these are implicitly relative to a particular module ).
Say that t is an h successor of (relative to the module ), just if t is an initial enumeration for and letting we have
Informally speaking, t is an h successor of s just if for all the state of when receives it’s initial enumeration during t agrees with that of excepting only elements can ignore as too large for it’s concern. Using this notion we can now define a notion of a sequence of intervals that look as if they are consecutive as far as is concerned.
Say that a sequence of intervals is -virtually consecutive (or just h-virtually consecutive) if
is not reinitialized during
At stage is in it’s initialized state, i.e., hasn’t been executed since it was last reinitialized.
is the least active stage greater than
For all , either is an h-successor of or and no elements are enumerated during the interval ending at and started at the prior active stage.
Every interval , satisfying the above between and appears in the above list.
Note that if the sequence is genuinely consecutive, i.e., for all k, then it is trivially h-virtually consecutive. Now let’s define what it means for a strategy to be successful.
Say that the strategy is a winning strategy if there is a number (the winning number for h) such that if is an h virtually consecutive sequence of intervals of length then, for any acceptable enumeration of elements into the sets satisfying there are distinct if the recommendations of are followed we have .
We leave the task of formalizing the notion of relative to any acceptable enumeration to the pedantic reader but take the intended content to be clear. In particular, a winning strategy is guaranteed to produce agreement in a bounded number of intervals even if we permute the indices to sets. With this notion in place we can finally demonstrate that our strategies are winning strategies.
Suppose that for all,the strategyis a winning strategy with winning numberthenis a winning strategy.
Suppose that is a sequence of h virtually consecutive intervals with with We argue there are with .
We now note that there must be a subsequence of length at least on which we always execute the same substrategy but never reinitialize that strategy. Specifically, we observe that there is an and a subsequence such that and for all with we have . This follows since if this isn’t witnessed by then there must be a subsequence of length at least .
As the support of h is finite we must eventually find such a subsequence. Call this a good subsequence and let , i.e., is the strategy called (if necessary) by in an interval in which the initial enumeration was into . Thinking of this in terms of a finite injury construction this subsequence represents the stages at which the strategy gets attention without intervening injury.
Suppose that for some we fail to enumerate any into during . We claim that . By h-virtual connectivity when begins execution at stage , is compatible with it’s state at stage . Note that, by Definition 5.9, we may assume that only are enumerated into any . Thus, in any interval the first element is enumerated at stage . When executes at stage the action of Step 2e cancels any elements enumerated both at stage and by any ancestor strategies executing Step 2f (which must occur earlier in that stage).
As no was enumerated during the interval , Step 2f never enumerates any elements and as no parent strategy enumerates any elements into the first two columns of after executing it’s child that agreement persists until the end of stage, and, indeed, the end of stage .
Thus, we can assume that we have a subsequence of length with of length during which we never reinitialize and during each interval there is a at which we execute . To verify the claim we first show that the sequence is virtually consecutive. Note that, here and that we may presume that this is the first such subsequence, i.e., is the first execution of since last reinitialization.
This leaves only part 4 of Definition 5.8 to be verified but this follows by Lemma 5.2. Now suppose that for some k the only element enumerated during the interval with into . By the same reasoning above we’ll see agreement at since this means that for we behave as above and the inductive hypothesis handles enumeration into . Thus, we can assume that in each interval we see some enumerated into . In this case, when that x is enumerated the operation of Step 2e by cancels any element enumerated at stage during Step 2f. Thus, the situation with respect to the first two columns of the sets is no different than if enumeration was restricted only to those x entering where . □
We can now prove our desired result.
acts only finitely many times.
Suppose not. The only possibility is that some module is initialized at some stage and never subsequently reinitialized by the action of any higher priority module. But this can only happen if at all active stages we have .
But, by Lemma 5.10 we have that is a winning strategy. Consider the sequence where is the first stage subsequent to at which claims an enumeration. As enumerations that go unclaimed or are claimed by modules with lower priority don’t enumerate elements that are small relative to the last stage at which acts into the first two columns of any it is trivial that this sequence is virtually contiguous. It thus follows that there are k, with and thus at stage we have contrary to our assumption. Hence every module acts only finitely often. □
Putting it together
Every requirement of the formis satisfied.
Assume, for a contradiction, isn’t satisfied (i.e., ) and that is the last stage at which the module acts. If then and since such a change would require act at that stage. Hence, .
If the variable c is defined for the at stage (i.e., if ) we leave that value in place but if not set where is the least m such that hasn’t been enumerated into . Note that must be defined at since if then acts at stage
By Lemma 3.7 let be a stage at which holds. But if then we have acts at stage . On the other hand if then we have . However, this is exactly what Lemma 3.9 denies. Contradiction! □
Before we can complete the proof of our main theorem we must fulfill the commitment we made in Condition 1 and verify that is total.
There are infinitely many stages s such thatfor alland thus. Thus, Condition
1
hold andis total.
Note that, this result entails that A is .
To verify the primary claim note that if acts at stage s it injures lower priority modules and when reinitialized those modules never enumerate an element into any column of A below . Thus, if is last stage that any module with priority acts we have for all and .
Condition 1 follows immediately and the totality of was observed to follow from this fact in the discussion immediately following Definition 3.11. □
We can now easily complete the proof of our main theorem.
There is a properlyset A which can’t be extended to a properlyset. The set A can also be taken to be.
By Lemma 5.12 to show that A is properly but can’t be expanded to a set it is enough to verify that the requirements of the form is satisfied. Clearly is total for all i and is total by Lemma 5.13. Hence, it’s enough to show that these functionals are correct at every stage. But by proposition 5.6 this holds as long as no module for is injured infinitely many times. However, as only modules of the form are responsible for injuries this is immediate from proposition 5.11.
The fact that A can be taken to be follows from Lemma 5.13. □
References
1.
G.J.Carl and R.A.Shore, Pseudo-jump operators. II: Transfinite iterations, hierarchies and minimal covers, The Journal of Symbolic Logic49(04) (1984), 1205–1236. doi:10.2307/2274273.
2.
P.A.Cholak and P.G.Hinman, Iterated relative recursive enumerability, Archive for Mathematical Logic33(5) (1994), 321–346. doi:10.1007/BF01278463.
3.
P.Odifreddi, Classical Recursion Theory: The Theory of Functions and Sets of Natural Numbers, Vol. 1, Elsevier, 1992.
4.
H.Rogers, Theory of Recursive Functions and Effective Computability, MIT Press, Cambridge, Mass, 1987.
5.
R.I.Soare and M.Stob, Relative recursive enumerability, in: Studies in Logic and the Foundations of Mathematics, Vol. 107, Elsevier, 1982, pp. 299–324.